git.delta.rocks / jrsonnet / refs/commits / 1450eba56177

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	/// Sanity checking, before trusting to another tests190	#[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		// `self` assigned to `me` was lost when being309		// referenced from field310		eval_stdlib!(311			r#"{312				local me = self,313				a: 3,314				b: me.a,315			}.b"#316		);317	}318319	// We can't trust other tests (And official jsonnet testsuite), if assert is not working correctly320	#[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}