1#![feature(box_syntax, box_patterns)]2#![feature(type_alias_impl_trait)]3#![feature(debug_non_exhaustive)]4#![allow(macro_expanded_macro_exports_accessed_by_absolute_paths)]5mod ctx;6mod dynamic;7mod evaluate;8mod obj;9mod val;1011pub use ctx::*;12pub use dynamic::*;13pub use evaluate::*;14use jsonnet_parser::*;15pub use obj::*;16use std::{cell::RefCell, collections::HashMap, rc::Rc};17pub use val::*;1819rc_fn_helper!(20 Binding,21 binding,22 dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Val23);24rc_fn_helper!(25 LazyBinding,26 lazy_binding,27 dyn Fn(Option<ObjValue>, Option<ObjValue>) -> LazyVal28);29rc_fn_helper!(FunctionRhs, function_rhs, dyn Fn(Context) -> Val);30rc_fn_helper!(31 FunctionDefault,32 function_default,33 dyn Fn(Context, LocExpr) -> Val34);3536pub struct ExitGuard<'s>(&'s EvaluationState);37impl<'s> Drop for ExitGuard<'s> {38 fn drop(&mut self) {39 self.0.stack.borrow_mut().pop();40 }41}4243pub struct EvaluationState {44 pub stack: Rc<RefCell<Vec<LocExpr>>>,45 pub files: Rc<RefCell<HashMap<String, String>>>,46}47impl EvaluationState {48 #[must_use = "should keep exit guard before exit from function"]49 pub fn push(&self, e: LocExpr) -> ExitGuard {50 self.stack.borrow_mut().push(e);51 ExitGuard(self)52 }53 pub fn print_stack_trace(&self) {54 for e in self55 .stack56 .borrow()57 .iter()58 .rev()59 .map(|e| e.1.clone())60 .flatten()61 {62 println!("{:?}", e)63 }64 }65}66impl Default for EvaluationState {67 fn default() -> Self {68 EvaluationState {69 stack: Rc::new(RefCell::new(Vec::new())),70 files: Rc::new(RefCell::new(HashMap::new())),71 }72 }73}7475#[cfg(test)]76pub mod tests {77 use super::{evaluate, Context, Val};78 use crate::EvaluationState;79 use jsonnet_parser::*;8081 #[test]82 fn eval_state_stacktrace() {83 let state = EvaluationState::default();84 let _v = state.push(loc_expr!(85 Expr::Num(0.0),86 true,87 ("test.jsonnet".to_owned(), 10, 20)88 ));8990 state.print_stack_trace()91 }9293 macro_rules! eval {94 ($str: expr) => {95 evaluate(96 Context::new(),97 &parse(98 $str,99 &ParserSettings {100 loc_data: true,101 file_name: "test.jsonnet".to_owned(),102 },103 )104 .unwrap(),105 )106 };107 }108109 macro_rules! eval_stdlib {110 ($str: expr) => {{111 let std = "local std = ".to_owned() + jsonnet_stdlib::STDLIB_STR + ";";112 evaluate(113 Context::new(),114 &parse(115 &(std + $str),116 &ParserSettings {117 loc_data: true,118 file_name: "test.jsonnet".to_owned(),119 },120 )121 .unwrap(),122 )123 }};124 }125126 macro_rules! assert_eval {127 ($str: expr) => {128 assert_eq!(129 evaluate(130 Context::new(),131 &parse(132 $str,133 &ParserSettings {134 loc_data: true,135 file_name: "test.jsonnet".to_owned(),136 }137 )138 .unwrap()139 ),140 Val::Bool(true)141 )142 };143 }144 macro_rules! assert_json {145 ($str: expr, $out: expr) => {146 assert_eq!(147 format!(148 "{}",149 evaluate(150 Context::new(),151 &parse(152 $str,153 &ParserSettings {154 loc_data: true,155 file_name: "test.jsonnet".to_owned(),156 }157 )158 .unwrap()159 )160 ),161 $out162 )163 };164 }165 macro_rules! assert_json_stdlib {166 ($str: expr, $out: expr) => {167 assert_eq!(format!("{}", eval_stdlib!($str)), $out)168 };169 }170 macro_rules! assert_eval_neg {171 ($str: expr) => {172 assert_eq!(173 evaluate(174 Context::new(),175 &parse(176 $str,177 &ParserSettings {178 loc_data: true,179 file_name: "test.jsonnet".to_owned(),180 }181 )182 .unwrap()183 ),184 Val::Bool(false)185 )186 };187 }188189 190 #[test]191 fn equality_operator() {192 assert_eval!("2 == 2");193 assert_eval_neg!("2 != 2");194 assert_eval!("2 != 3");195 assert_eval_neg!("2 == 3");196 assert_eval!("'Hello' == 'Hello'");197 assert_eval_neg!("'Hello' != 'Hello'");198 assert_eval!("'Hello' != 'World'");199 assert_eval_neg!("'Hello' == 'World'");200 }201202 #[test]203 fn math_evaluation() {204 assert_eval!("2 + 2 * 2 == 6");205 assert_eval!("3 + (2 + 2 * 2) == 9");206 }207208 #[test]209 fn string_concat() {210 assert_eval!("'Hello' + 'World' == 'HelloWorld'");211 assert_eval!("'Hello' * 3 == 'HelloHelloHello'");212 assert_eval!("'Hello' + 'World' * 3 == 'HelloWorldWorldWorld'");213 }214215 #[test]216 fn local() {217 assert_eval!("local a = 2; local b = 3; a + b == 5");218 assert_eval!("local a = 1, b = a + 1; a + b == 3");219 assert_eval!("local a = 1; local a = 2; a == 2");220 }221222 #[test]223 fn object_lazyness() {224 assert_json!("local a = {a:error 'test'}; {}", r#"{}"#);225 }226227 #[test]228 fn object_inheritance() {229 assert_json!("{a: self.b} + {b:3}", r#"{"a":3,"b":3}"#);230 }231232 #[test]233 fn test_object() {234 assert_json!("{a:2}", r#"{"a":2}"#);235 assert_json!("{a:2+2}", r#"{"a":4}"#);236 assert_json!("{a:2}+{b:2}", r#"{"a":2,"b":2}"#);237 assert_json!("{b:3}+{b:2}", r#"{"b":2}"#);238 assert_json!("{b:3}+{b+:2}", r#"{"b":5}"#);239 assert_json!("local test='a'; {[test]:2}", r#"{"a":2}"#);240 assert_json!(241 r#"242 {243 name: "Alice",244 welcome: "Hello " + self.name + "!",245 }246 "#,247 r#"{"name":"Alice","welcome":"Hello Alice!"}"#248 );249 assert_json!(250 r#"251 {252 name: "Alice",253 welcome: "Hello " + self.name + "!",254 } + {255 name: "Bob"256 }257 "#,258 r#"{"name":"Bob","welcome":"Hello Bob!"}"#259 );260 }261262 #[test]263 fn functions() {264 assert_json!(r#"local a = function(b, c = 2) b + c; a(2)"#, "4");265 assert_json!(266 r#"local a = function(b, c = "Dear") b + c + d, d = "World"; a("Hello")"#,267 r#""HelloDearWorld""#268 );269 }270271 #[test]272 fn local_methods() {273 assert_json!(r#"local a(b, c = 2) = b + c; a(2)"#, "4");274 assert_json!(275 r#"local a(b, c = "Dear") = b + c + d, d = "World"; a("Hello")"#,276 r#""HelloDearWorld""#277 );278 }279280 #[test]281 fn object_locals() {282 assert_json!(r#"{local a = 3, b: a}"#, r#"{"b":3}"#);283 assert_json!(r#"{local a = 3, local c = a, b: c}"#, r#"{"b":3}"#);284 assert_json!(285 r#"{local a = function (b) {[b]:4}, test: a("test")}"#,286 r#"{"test":{"test":4}}"#287 );288 }289290 #[test]291 fn direct_self() {292 println!(293 "{:#?}",294 eval!(295 r#"296 {297 local me = self,298 a: 3,299 b(): me.a,300 }301 "#302 )303 );304 }305306 #[test]307 fn indirect_self() {308 309 310 eval_stdlib!(311 r#"{312 local me = self,313 a: 3,314 b: me.a,315 }.b"#316 );317 }318319 320 #[test]321 fn std_assert_ok() {322 eval_stdlib!("std.assertEqual(4.5 << 2, 16)");323 }324325 #[test]326 #[should_panic]327 fn std_assert_failure() {328 eval_stdlib!("std.assertEqual(4.5 << 2, 15)");329 }330331 #[test]332 fn string_is_string() {333 assert_eq!(334 eval_stdlib!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),335 Val::Bool(false)336 );337 }338339 #[test]340 fn base64_works() {341 assert_json_stdlib!(r#"std.base64("test")"#, r#""dGVzdA==""#);342 }343344 #[test]345 fn utf8_chars() {346 assert_json_stdlib!(347 r#"local c="😎";{c:std.codepoint(c),l:std.length(c)}"#,348 r#"{"c":128526,"l":1}"#349 )350 }351352 #[test]353 fn json() {354 println!("{:?}", eval_stdlib!(r#"std.manifestJson({a:3, b:4, c:6})"#));355 }356357 #[test]358 fn sjsonnet() {359 eval!(360 r#"361 local x0 = {k: 1};362 local x1 = {k: x0.k + x0.k};363 local x2 = {k: x1.k + x1.k};364 local x3 = {k: x2.k + x2.k};365 local x4 = {k: x3.k + x3.k};366 local x5 = {k: x4.k + x4.k};367 local x6 = {k: x5.k + x5.k};368 local x7 = {k: x6.k + x6.k};369 local x8 = {k: x7.k + x7.k};370 local x9 = {k: x8.k + x8.k};371 local x10 = {k: x9.k + x9.k};372 local x11 = {k: x10.k + x10.k};373 local x12 = {k: x11.k + x11.k};374 local x13 = {k: x12.k + x12.k};375 local x14 = {k: x13.k + x13.k};376 local x15 = {k: x14.k + x14.k};377 local x16 = {k: x15.k + x15.k};378 local x17 = {k: x16.k + x16.k};379 local x18 = {k: x17.k + x17.k};380 local x19 = {k: x18.k + x18.k};381 local x20 = {k: x19.k + x19.k};382 local x21 = {k: x20.k + x20.k};383 x21.k384 "#385 );386 }387}