1#![feature(box_syntax, box_patterns)]2#![feature(type_alias_impl_trait)]3#![feature(debug_non_exhaustive)]4#![feature(test)]5#![allow(macro_expanded_macro_exports_accessed_by_absolute_paths)]67extern crate test;89mod ctx;10mod dynamic;11mod error;12mod evaluate;13mod function;14mod import;15mod map;16mod obj;17mod val;1819pub use ctx::*;20pub use dynamic::*;21pub use error::*;22pub use evaluate::*;23pub use function::parse_function_call;24pub use import::*;25use jsonnet_parser::*;26pub use obj::*;27use std::{cell::RefCell, collections::HashMap, fmt::Debug, path::PathBuf, rc::Rc};28pub use val::*;2930type BindableFn = dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Result<LazyVal>;31#[derive(Clone)]32pub enum LazyBinding {33 Bindable(Rc<BindableFn>),34 Bound(LazyVal),35}3637impl Debug for LazyBinding {38 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {39 write!(f, "LazyBinding")40 }41}42impl LazyBinding {43 pub fn evaluate(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {44 match self {45 LazyBinding::Bindable(v) => v(this, super_obj),46 LazyBinding::Bound(v) => Ok(v.clone()),47 }48 }49}5051pub struct EvaluationSettings {52 pub max_stack_frames: usize,53 pub max_stack_trace_size: usize,54}55impl Default for EvaluationSettings {56 fn default() -> Self {57 EvaluationSettings {58 max_stack_frames: 200,59 max_stack_trace_size: 20,60 }61 }62}6364pub struct FileData(Rc<str>, LocExpr, Option<Val>);65#[derive(Default)]66pub struct EvaluationStateInternals {67 68 stack: RefCell<Vec<StackTraceElement>>,69 70 71 files: RefCell<HashMap<Rc<PathBuf>, FileData>>,72 str_files: RefCell<HashMap<Rc<PathBuf>, Rc<str>>>,73 globals: RefCell<HashMap<Rc<str>, Val>>,7475 76 ext_vars: RefCell<HashMap<Rc<str>, Val>>,7778 settings: EvaluationSettings,79 import_resolver: Box<dyn ImportResolver>,80}8182thread_local! {83 84 85 pub(crate) static EVAL_STATE: RefCell<Option<EvaluationState>> = RefCell::new(None)86}87pub(crate) fn with_state<T>(f: impl FnOnce(&EvaluationState) -> T) -> T {88 EVAL_STATE.with(|s| f(s.borrow().as_ref().unwrap()))89}90pub(crate) fn create_error<T>(err: Error) -> Result<T> {91 with_state(|s| s.error(err))92}93pub(crate) fn push<T>(94 e: &Option<ExprLocation>,95 comment: &str,96 f: impl FnOnce() -> Result<T>,97) -> Result<T> {98 if e.is_some() {99 with_state(|s| s.push(e.clone().unwrap(), comment.to_owned(), f))100 } else {101 f()102 }103}104105106#[derive(Default, Clone)]107pub struct EvaluationState(Rc<EvaluationStateInternals>);108impl EvaluationState {109 pub fn new(settings: EvaluationSettings, import_resolver: Box<dyn ImportResolver>) -> Self {110 EvaluationState(Rc::new(EvaluationStateInternals {111 settings,112 import_resolver,113 ..Default::default()114 }))115 }116 pub fn add_file(117 &self,118 name: Rc<PathBuf>,119 code: Rc<str>,120 ) -> std::result::Result<(), ParseError> {121 self.0.files.borrow_mut().insert(122 name.clone(),123 FileData(124 code.clone(),125 parse(126 &code,127 &ParserSettings {128 file_name: name,129 loc_data: true,130 },131 )?,132 None,133 ),134 );135136 Ok(())137 }138 pub fn add_parsed_file(139 &self,140 name: Rc<PathBuf>,141 code: Rc<str>,142 parsed: LocExpr,143 ) -> std::result::Result<(), ()> {144 self.0145 .files146 .borrow_mut()147 .insert(name, FileData(code, parsed, None));148149 Ok(())150 }151 pub fn get_source(&self, name: &PathBuf) -> Option<Rc<str>> {152 let ro_map = self.0.files.borrow();153 ro_map.get(name).map(|value| value.0.clone())154 }155 pub fn evaluate_file(&self, name: &PathBuf) -> Result<Val> {156 self.run_in_state(|| {157 let expr: LocExpr = {158 let ro_map = self.0.files.borrow();159 let value = ro_map160 .get(name)161 .unwrap_or_else(|| panic!("file not added: {:?}", name));162 if value.2.is_some() {163 return Ok(value.2.clone().unwrap());164 }165 value.1.clone()166 };167 let value = evaluate(self.create_default_context()?, &expr)?;168 {169 self.0170 .files171 .borrow_mut()172 .get_mut(name)173 .unwrap()174 .2175 .replace(value.clone());176 }177 Ok(value)178 })179 }180 pub(crate) fn import_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Val> {181 let file_path = self.0.import_resolver.resolve_file(from, path)?;182 {183 let files = self.0.files.borrow();184 if files.contains_key(&file_path) {185 return self.evaluate_file(&file_path);186 }187 }188 let contents = self.0.import_resolver.load_file_contents(&file_path)?;189 self.add_file(file_path.clone(), contents).map_err(|e| {190 create_error::<()>(Error::ImportSyntaxError(e))191 .err()192 .unwrap()193 })?;194 self.evaluate_file(&file_path)195 }196 pub(crate) fn import_file_str(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<str>> {197 let path = self.0.import_resolver.resolve_file(from, path)?;198 if !self.0.str_files.borrow().contains_key(&path) {199 let file_str = self.0.import_resolver.load_file_contents(&path)?;200 self.0201 .str_files202 .borrow_mut()203 .insert(path.clone(), file_str);204 }205 Ok(self.0.str_files.borrow().get(&path).cloned().unwrap())206 }207208 pub fn parse_evaluate_raw(&self, code: &str) -> Result<Val> {209 let parsed = parse(210 &code,211 &ParserSettings {212 file_name: Rc::new(PathBuf::from("raw.jsonnet")),213 loc_data: true,214 },215 )216 .unwrap();217 self.evaluate_raw(parsed)218 }219220 pub fn evaluate_raw(&self, code: LocExpr) -> Result<Val> {221 self.run_in_state(|| evaluate(self.create_default_context()?, &code))222 }223224 pub fn add_global(&self, name: Rc<str>, value: Val) {225 self.0.globals.borrow_mut().insert(name, value);226 }227 pub fn add_ext_var(&self, name: Rc<str>, value: Val) {228 self.0.ext_vars.borrow_mut().insert(name, value);229 }230231 pub fn with_stdlib(&self) -> &Self {232 let std_path = Rc::new(PathBuf::from("std.jsonnet"));233 self.run_in_state(|| {234 use jsonnet_stdlib::STDLIB_STR;235 let mut parsed = false;236 #[cfg(feature = "codegenerated-stdlib")]237 if !parsed {238 parsed = true;239 #[allow(clippy::all)]240 let stdlib = {241 use jsonnet_parser::*;242 include!(concat!(env!("OUT_DIR"), "/stdlib.rs"))243 };244 self.add_parsed_file(std_path.clone(), STDLIB_STR.to_owned().into(), stdlib)245 .unwrap();246 }247248 #[cfg(feature = "serialized-stdlib")]249 if !parsed {250 parsed = true;251 self.add_parsed_file(252 std_path.clone(),253 STDLIB_STR.to_owned().into(),254 bincode::deserialize(include_bytes!(concat!(255 env!("OUT_DIR"),256 "/stdlib.bincode"257 )))258 .expect("deserialize stdlib"),259 )260 .unwrap();261 }262263 if !parsed {264 self.add_file(std_path, STDLIB_STR.to_owned().into())265 .unwrap();266 }267 let val = self.evaluate_file(&PathBuf::from("std.jsonnet")).unwrap();268 self.add_global("std".into(), val);269 });270 self271 }272273 pub fn create_default_context(&self) -> Result<Context> {274 let globals = self.0.globals.borrow();275 let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();276 for (name, value) in globals.iter() {277 new_bindings.insert(278 name.clone(),279 LazyBinding::Bound(resolved_lazy_val!(value.clone())),280 );281 }282 Context::new().extend_unbound(new_bindings, None, None, None)283 }284285 pub fn push<T>(286 &self,287 e: ExprLocation,288 comment: String,289 f: impl FnOnce() -> Result<T>,290 ) -> Result<T> {291 {292 let mut stack = self.0.stack.borrow_mut();293 if stack.len() > self.0.settings.max_stack_frames {294 drop(stack);295 return self.error(Error::StackOverflow);296 } else {297 stack.push(StackTraceElement(e, comment));298 }299 }300 let result = f();301 self.0.stack.borrow_mut().pop();302 result303 }304 pub fn print_stack_trace(&self) {305 for e in self.stack_trace().0 {306 println!("{:?} - {:?}", e.0, e.1)307 }308 }309 pub fn stack_trace(&self) -> StackTrace {310 StackTrace(311 self.0312 .stack313 .borrow()314 .iter()315 .rev()316 .take(self.0.settings.max_stack_trace_size)317 .cloned()318 .collect(),319 )320 }321 pub fn error<T>(&self, err: Error) -> Result<T> {322 Err(LocError(err, self.stack_trace()))323 }324325 pub fn run_in_state<T>(&self, f: impl FnOnce() -> T) -> T {326 EVAL_STATE.with(|v| {327 let has_state = v.borrow().is_some();328 if !has_state {329 v.borrow_mut().replace(self.clone());330 }331 let result = f();332 if !has_state {333 v.borrow_mut().take();334 }335 result336 })337 }338}339340#[cfg(test)]341pub mod tests {342 use super::Val;343 use crate::EvaluationState;344 use jsonnet_parser::*;345 use std::{path::PathBuf, rc::Rc};346347 #[test]348 fn eval_state_stacktrace() {349 let state = EvaluationState::default();350 state351 .push(352 ExprLocation(Rc::new(PathBuf::from("test1.jsonnet")), 10, 20),353 "outer".to_owned(),354 || {355 state.push(356 ExprLocation(Rc::new(PathBuf::from("test2.jsonnet")), 30, 40),357 "inner".to_owned(),358 || {359 state.print_stack_trace();360 Ok(())361 },362 )?;363 Ok(())364 },365 )366 .unwrap();367 }368369 #[test]370 fn eval_state_standard() {371 let state = EvaluationState::default();372 state.with_stdlib();373 assert_eq!(374 state375 .parse_evaluate_raw(r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#)376 .unwrap(),377 Val::Bool(true)378 );379 }380381 macro_rules! eval {382 ($str: expr) => {383 EvaluationState::default()384 .with_stdlib()385 .parse_evaluate_raw($str)386 .unwrap()387 };388 }389 macro_rules! eval_json {390 ($str: expr) => {{391 let evaluator = EvaluationState::default();392 evaluator.with_stdlib();393 evaluator.run_in_state(||{394 evaluator395 .parse_evaluate_raw($str)396 .unwrap()397 .into_json(0)398 .unwrap()399 .replace("\n", "")400 })401 }}402 }403404 405 macro_rules! assert_eval {406 ($str: expr) => {407 assert_eq!(eval!($str), Val::Bool(true))408 };409 }410411 412 macro_rules! assert_eval_neg {413 ($str: expr) => {414 assert_eq!(eval!($str), Val::Bool(false))415 };416 }417 macro_rules! assert_json {418 ($str: expr, $out: expr) => {419 assert_eq!(eval_json!($str), $out.replace("\t", ""))420 };421 }422423 424 #[test]425 fn equality_operator() {426 assert_eval!("2 == 2");427 assert_eval_neg!("2 != 2");428 assert_eval!("2 != 3");429 assert_eval_neg!("2 == 3");430 assert_eval!("'Hello' == 'Hello'");431 assert_eval_neg!("'Hello' != 'Hello'");432 assert_eval!("'Hello' != 'World'");433 assert_eval_neg!("'Hello' == 'World'");434 }435436 #[test]437 fn math_evaluation() {438 assert_eval!("2 + 2 * 2 == 6");439 assert_eval!("3 + (2 + 2 * 2) == 9");440 }441442 #[test]443 fn string_concat() {444 assert_eval!("'Hello' + 'World' == 'HelloWorld'");445 assert_eval!("'Hello' * 3 == 'HelloHelloHello'");446 assert_eval!("'Hello' + 'World' * 3 == 'HelloWorldWorldWorld'");447 }448449 #[test]450 fn faster_join() {451 assert_eval!("std.join([0,0], [[1,2],[3,4],[5,6]]) == [1,2,0,0,3,4,0,0,5,6]");452 assert_eval!("std.join(',', ['1','2','3','4']) == '1,2,3,4'");453 }454455 #[test]456 fn function_contexts() {457 assert_eval!(458 r#"459 local k = {460 t(name = self.h): [self.h, name],461 h: 3,462 };463 local f = {464 t: k.t(),465 h: 4,466 };467 f.t[0] == f.t[1]468 "#469 );470 }471472 #[test]473 fn local() {474 assert_eval!("local a = 2; local b = 3; a + b == 5");475 assert_eval!("local a = 1, b = a + 1; a + b == 3");476 assert_eval!("local a = 1; local a = 2; a == 2");477 }478479 #[test]480 fn object_lazyness() {481 assert_json!("local a = {a:error 'test'}; {}", r#"{}"#);482 }483484 #[test]485 fn object_inheritance() {486 assert_json!("{a: self.b} + {b:3}", r#"{"a": 3,"b": 3}"#);487 }488489 #[test]490 fn object_assertion_success() {491 eval!("{assert \"a\" in self} + {a:2}");492 }493494 #[test]495 fn object_assertion_error() {496 eval!("{assert \"a\" in self}");497 }498499 #[test]500 fn lazy_args() {501 eval!("local test(a) = 2; test(error '3')");502 }503504 #[test]505 #[should_panic]506 fn tailstrict_args() {507 eval!("local test(a) = 2; test(error '3') tailstrict");508 }509510 #[test]511 #[should_panic]512 fn no_binding_error() {513 eval!("a");514 }515516 #[test]517 fn test_object() {518 assert_json!("{a:2}", r#"{"a": 2}"#);519 assert_json!("{a:2+2}", r#"{"a": 4}"#);520 assert_json!("{a:2}+{b:2}", r#"{"a": 2,"b": 2}"#);521 assert_json!("{b:3}+{b:2}", r#"{"b": 2}"#);522 assert_json!("{b:3}+{b+:2}", r#"{"b": 5}"#);523 assert_json!("local test='a'; {[test]:2}", r#"{"a": 2}"#);524 assert_json!(525 r#"526 {527 name: "Alice",528 welcome: "Hello " + self.name + "!",529 }530 "#,531 r#"{"name": "Alice","welcome": "Hello Alice!"}"#532 );533 assert_json!(534 r#"535 {536 name: "Alice",537 welcome: "Hello " + self.name + "!",538 } + {539 name: "Bob"540 }541 "#,542 r#"{"name": "Bob","welcome": "Hello Bob!"}"#543 );544 }545546 #[test]547 fn functions() {548 assert_json!(r#"local a = function(b, c = 2) b + c; a(2)"#, "4");549 assert_json!(550 r#"local a = function(b, c = "Dear") b + c + d, d = "World"; a("Hello")"#,551 r#""HelloDearWorld""#552 );553 }554555 #[test]556 fn local_methods() {557 assert_json!(r#"local a(b, c = 2) = b + c; a(2)"#, "4");558 assert_json!(559 r#"local a(b, c = "Dear") = b + c + d, d = "World"; a("Hello")"#,560 r#""HelloDearWorld""#561 );562 }563564 #[test]565 fn object_locals() {566 assert_json!(r#"{local a = 3, b: a}"#, r#"{"b": 3}"#);567 assert_json!(r#"{local a = 3, local c = a, b: c}"#, r#"{"b": 3}"#);568 assert_json!(569 r#"{local a = function (b) {[b]:4}, test: a("test")}"#,570 r#"{"test": {"test": 4}}"#571 );572 }573574 #[test]575 fn object_comp() {576 assert_json!(577 r#"{local t = "a", ["h"+i+"_"+z]: if "h"+(i-1)+"_"+z in self then t+1 else 0+t for i in [1,2,3] for z in [2,3,4] if z != i}"#,578 "{\"h1_2\": \"0a\",\"h1_3\": \"0a\",\"h1_4\": \"0a\",\"h2_3\": \"a1\",\"h2_4\": \"a1\",\"h3_2\": \"0a\",\"h3_4\": \"a1\"}"579 )580 }581582 #[test]583 fn direct_self() {584 println!(585 "{:#?}",586 eval!(587 r#"588 {589 local me = self,590 a: 3,591 b(): me.a,592 }593 "#594 )595 );596 }597598 #[test]599 fn indirect_self() {600 601 602 eval!(603 r#"{604 local me = self,605 a: 3,606 b: me.a,607 }.b"#608 );609 }610611 612 #[test]613 fn std_assert_ok() {614 eval!("std.assertEqual(4.5 << 2, 16)");615 }616617 #[test]618 #[should_panic]619 fn std_assert_failure() {620 eval!("std.assertEqual(4.5 << 2, 15)");621 }622623 #[test]624 fn string_is_string() {625 assert_eq!(626 eval!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),627 Val::Bool(false)628 );629 }630631 #[test]632 fn base64_works() {633 assert_json!(r#"std.base64("test")"#, r#""dGVzdA==""#);634 }635636 #[test]637 fn utf8_chars() {638 assert_json!(639 r#"local c="😎";{c:std.codepoint(c),l:std.length(c)}"#,640 r#"{"c": 128526,"l": 1}"#641 )642 }643644 #[test]645 fn json() {646 assert_json!(647 r#"std.manifestJsonEx({a:3, b:4, c:6},"")"#,648 r#""{\n\"a\": 3,\n\"b\": 4,\n\"c\": 6\n}""#649 );650 }651652 #[test]653 fn test() {654 assert_json!(655 r#"[[a, b] for a in [1,2,3] for b in [4,5,6]]"#,656 "[[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]"657 );658 }659660 #[test]661 fn sjsonnet() {662 eval!(663 r#"664 local x0 = {k: 1};665 local x1 = {k: x0.k + x0.k};666 local x2 = {k: x1.k + x1.k};667 local x3 = {k: x2.k + x2.k};668 local x4 = {k: x3.k + x3.k};669 local x5 = {k: x4.k + x4.k};670 local x6 = {k: x5.k + x5.k};671 local x7 = {k: x6.k + x6.k};672 local x8 = {k: x7.k + x7.k};673 local x9 = {k: x8.k + x8.k};674 local x10 = {k: x9.k + x9.k};675 local x11 = {k: x10.k + x10.k};676 local x12 = {k: x11.k + x11.k};677 local x13 = {k: x12.k + x12.k};678 local x14 = {k: x13.k + x13.k};679 local x15 = {k: x14.k + x14.k};680 local x16 = {k: x15.k + x15.k};681 local x17 = {k: x16.k + x16.k};682 local x18 = {k: x17.k + x17.k};683 local x19 = {k: x18.k + x18.k};684 local x20 = {k: x19.k + x19.k};685 local x21 = {k: x20.k + x20.k};686 x21.k687 "#688 );689 }690691 use test::Bencher;692693 694 695 696 697 698 699 700 701 702 703 704 705706 #[bench]707 fn bench_serialize(b: &mut Bencher) {708 b.iter(|| {709 bincode::deserialize::<jsonnet_parser::LocExpr>(include_bytes!(concat!(710 env!("OUT_DIR"),711 "/stdlib.bincode"712 )))713 .expect("deserialize stdlib")714 })715 }716717 #[bench]718 fn bench_parse(b: &mut Bencher) {719 b.iter(|| {720 jsonnet_parser::parse(721 jsonnet_stdlib::STDLIB_STR,722 &jsonnet_parser::ParserSettings {723 loc_data: true,724 file_name: Rc::new(PathBuf::from("std.jsonnet")),725 },726 )727 })728 }729}