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 error;8mod evaluate;9mod function;10mod import;11mod map;12mod obj;13mod val;1415pub use ctx::*;16pub use dynamic::*;17pub use error::*;18pub use evaluate::*;19pub use function::parse_function_call;20pub use import::*;21use jsonnet_parser::*;22pub use obj::*;23use std::{cell::RefCell, collections::HashMap, fmt::Debug, path::PathBuf, rc::Rc};24pub use val::*;2526type BindableFn = dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Result<LazyVal>;27#[derive(Clone)]28pub enum LazyBinding {29 Bindable(Rc<BindableFn>),30 Bound(LazyVal),31}3233impl Debug for LazyBinding {34 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {35 write!(f, "LazyBinding")36 }37}38impl LazyBinding {39 pub fn evaluate(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {40 match self {41 LazyBinding::Bindable(v) => v(this, super_obj),42 LazyBinding::Bound(v) => Ok(v.clone()),43 }44 }45}4647pub struct EvaluationSettings {48 pub max_stack_frames: usize,49 pub max_stack_trace_size: usize,50}51impl Default for EvaluationSettings {52 fn default() -> Self {53 EvaluationSettings {54 max_stack_frames: 200,55 max_stack_trace_size: 20,56 }57 }58}5960pub struct FileData(Rc<str>, LocExpr, Option<Val>);61#[derive(Default)]62pub struct EvaluationStateInternals {63 64 stack: RefCell<Vec<StackTraceElement>>,65 66 67 files: RefCell<HashMap<Rc<PathBuf>, FileData>>,68 str_files: RefCell<HashMap<Rc<PathBuf>, Rc<str>>>,69 globals: RefCell<HashMap<Rc<str>, Val>>,7071 72 ext_vars: RefCell<HashMap<Rc<str>, Val>>,7374 settings: EvaluationSettings,75 import_resolver: Box<dyn ImportResolver>,76}7778thread_local! {79 80 81 pub(crate) static EVAL_STATE: RefCell<Option<EvaluationState>> = RefCell::new(None)82}83pub(crate) fn with_state<T>(f: impl FnOnce(&EvaluationState) -> T) -> T {84 EVAL_STATE.with(|s| f(s.borrow().as_ref().unwrap()))85}86pub(crate) fn create_error<T>(err: Error) -> Result<T> {87 with_state(|s| s.error(err))88}89pub(crate) fn push<T>(90 e: &Option<ExprLocation>,91 comment: &str,92 f: impl FnOnce() -> Result<T>,93) -> Result<T> {94 if e.is_some() {95 with_state(|s| s.push(e.clone().unwrap(), comment.to_owned(), f))96 } else {97 f()98 }99}100101102#[derive(Default, Clone)]103pub struct EvaluationState(Rc<EvaluationStateInternals>);104impl EvaluationState {105 pub fn new(settings: EvaluationSettings, import_resolver: Box<dyn ImportResolver>) -> Self {106 EvaluationState(Rc::new(EvaluationStateInternals {107 settings,108 import_resolver,109 ..Default::default()110 }))111 }112 pub fn add_file(113 &self,114 name: Rc<PathBuf>,115 code: Rc<str>,116 ) -> std::result::Result<(), ParseError> {117 self.0.files.borrow_mut().insert(118 name.clone(),119 FileData(120 code.clone(),121 parse(122 &code,123 &ParserSettings {124 file_name: name,125 loc_data: true,126 },127 )?,128 None,129 ),130 );131132 Ok(())133 }134 pub fn add_parsed_file(135 &self,136 name: Rc<PathBuf>,137 code: Rc<str>,138 parsed: LocExpr,139 ) -> std::result::Result<(), ()> {140 self.0141 .files142 .borrow_mut()143 .insert(name, FileData(code, parsed, None));144145 Ok(())146 }147 pub fn get_source(&self, name: &PathBuf) -> Option<Rc<str>> {148 let ro_map = self.0.files.borrow();149 ro_map.get(name).map(|value| value.0.clone())150 }151 pub fn evaluate_file(&self, name: &PathBuf) -> Result<Val> {152 self.run_in_state(|| {153 let expr: LocExpr = {154 let ro_map = self.0.files.borrow();155 let value = ro_map156 .get(name)157 .unwrap_or_else(|| panic!("file not added: {:?}", name));158 if value.2.is_some() {159 return Ok(value.2.clone().unwrap());160 }161 value.1.clone()162 };163 let value = evaluate(self.create_default_context()?, &expr)?;164 {165 self.0166 .files167 .borrow_mut()168 .get_mut(name)169 .unwrap()170 .2171 .replace(value.clone());172 }173 Ok(value)174 })175 }176 pub(crate) fn import_file(&self, from: &PathBuf, path: &PathBuf) -> Result<Val> {177 let file_path = self.0.import_resolver.resolve_file(from, path)?;178 {179 let files = self.0.files.borrow();180 if files.contains_key(&file_path) {181 return self.evaluate_file(&file_path);182 }183 }184 let contents = self.0.import_resolver.load_file_contents(&file_path)?;185 self.add_file(file_path.clone(), contents).map_err(|e| {186 create_error::<()>(Error::ImportSyntaxError(e))187 .err()188 .unwrap()189 })?;190 self.evaluate_file(&file_path)191 }192 pub(crate) fn import_file_str(&self, from: &PathBuf, path: &PathBuf) -> Result<Rc<str>> {193 let path = self.0.import_resolver.resolve_file(from, path)?;194 if !self.0.str_files.borrow().contains_key(&path) {195 let file_str = self.0.import_resolver.load_file_contents(&path)?;196 self.0197 .str_files198 .borrow_mut()199 .insert(path.clone(), file_str.into());200 }201 Ok(self.0.str_files.borrow().get(&path).cloned().unwrap())202 }203204 pub fn parse_evaluate_raw(&self, code: &str) -> Result<Val> {205 let parsed = parse(206 &code,207 &ParserSettings {208 file_name: Rc::new(PathBuf::from("raw.jsonnet")),209 loc_data: true,210 },211 )212 .unwrap();213 self.evaluate_raw(parsed)214 }215216 pub fn evaluate_raw(&self, code: LocExpr) -> Result<Val> {217 self.run_in_state(|| evaluate(self.create_default_context()?, &code))218 }219220 pub fn add_global(&self, name: Rc<str>, value: Val) {221 self.0.globals.borrow_mut().insert(name, value);222 }223 pub fn add_ext_var(&self, name: Rc<str>, value: Val) {224 self.0.ext_vars.borrow_mut().insert(name, value);225 }226227 pub fn with_stdlib(&self) -> &Self {228 let std_path = Rc::new(PathBuf::from("std.jsonnet"));229 self.run_in_state(|| {230 use jsonnet_stdlib::STDLIB_STR;231 if cfg!(feature = "serialized-stdlib") {232 self.add_parsed_file(233 std_path,234 STDLIB_STR.to_owned().into(),235 bincode::deserialize(include_bytes!(concat!(236 env!("OUT_DIR"),237 "/stdlib.bincode"238 )))239 .expect("deserialize stdlib"),240 )241 .unwrap();242 } else {243 self.add_file(std_path, STDLIB_STR.to_owned().into())244 .unwrap();245 }246 let val = self.evaluate_file(&PathBuf::from("std.jsonnet")).unwrap();247 self.add_global("std".into(), val);248 });249 self250 }251252 pub fn create_default_context(&self) -> Result<Context> {253 let globals = self.0.globals.borrow();254 let mut new_bindings: HashMap<Rc<str>, LazyBinding> = HashMap::new();255 for (name, value) in globals.iter() {256 new_bindings.insert(257 name.clone(),258 LazyBinding::Bound(resolved_lazy_val!(value.clone())),259 );260 }261 Context::new().extend_unbound(new_bindings, None, None, None)262 }263264 pub fn push<T>(265 &self,266 e: ExprLocation,267 comment: String,268 f: impl FnOnce() -> Result<T>,269 ) -> Result<T> {270 {271 let mut stack = self.0.stack.borrow_mut();272 if stack.len() > self.0.settings.max_stack_frames {273 drop(stack);274 return self.error(Error::StackOverflow);275 } else {276 stack.push(StackTraceElement(e, comment));277 }278 }279 let result = f();280 self.0.stack.borrow_mut().pop();281 result282 }283 pub fn print_stack_trace(&self) {284 for e in self.stack_trace().0 {285 println!("{:?} - {:?}", e.0, e.1)286 }287 }288 pub fn stack_trace(&self) -> StackTrace {289 StackTrace(290 self.0291 .stack292 .borrow()293 .iter()294 .rev()295 .take(self.0.settings.max_stack_trace_size)296 .cloned()297 .collect(),298 )299 }300 pub fn error<T>(&self, err: Error) -> Result<T> {301 Err(LocError(err, self.stack_trace()))302 }303304 pub fn run_in_state<T>(&self, f: impl FnOnce() -> T) -> T {305 EVAL_STATE.with(|v| {306 let has_state = v.borrow().is_some();307 if !has_state {308 v.borrow_mut().replace(self.clone());309 }310 let result = f();311 if !has_state {312 v.borrow_mut().take();313 }314 result315 })316 }317}318319#[cfg(test)]320pub mod tests {321 use super::Val;322 use crate::EvaluationState;323 use jsonnet_parser::*;324 use std::{path::PathBuf, rc::Rc};325326 #[test]327 fn eval_state_stacktrace() {328 let state = EvaluationState::default();329 state330 .push(331 ExprLocation(Rc::new(PathBuf::from("test1.jsonnet")), 10, 20),332 "outer".to_owned(),333 || {334 state.push(335 ExprLocation(Rc::new(PathBuf::from("test2.jsonnet")), 30, 40),336 "inner".to_owned(),337 || {338 state.print_stack_trace();339 Ok(())340 },341 )?;342 Ok(())343 },344 )345 .unwrap();346 }347348 #[test]349 fn eval_state_standard() {350 let state = EvaluationState::default();351 state.with_stdlib();352 assert_eq!(353 state354 .parse_evaluate_raw(r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#)355 .unwrap(),356 Val::Bool(true)357 );358 }359360 macro_rules! eval {361 ($str: expr) => {362 EvaluationState::default()363 .with_stdlib()364 .parse_evaluate_raw($str)365 .unwrap()366 };367 }368 macro_rules! eval_json {369 ($str: expr) => {{370 let evaluator = EvaluationState::default();371 evaluator.with_stdlib();372 evaluator373 .parse_evaluate_raw($str)374 .unwrap()375 .into_json(0)376 .unwrap()377 .replace("\n", "")378 }};379 }380381 382 macro_rules! assert_eval {383 ($str: expr) => {384 assert_eq!(eval!($str), Val::Bool(true))385 };386 }387388 389 macro_rules! assert_eval_neg {390 ($str: expr) => {391 assert_eq!(eval!($str), Val::Bool(false))392 };393 }394 macro_rules! assert_json {395 ($str: expr, $out: expr) => {396 assert_eq!(eval_json!($str), $out.replace("\t", ""))397 };398 }399400 401 #[test]402 fn equality_operator() {403 assert_eval!("2 == 2");404 assert_eval_neg!("2 != 2");405 assert_eval!("2 != 3");406 assert_eval_neg!("2 == 3");407 assert_eval!("'Hello' == 'Hello'");408 assert_eval_neg!("'Hello' != 'Hello'");409 assert_eval!("'Hello' != 'World'");410 assert_eval_neg!("'Hello' == 'World'");411 }412413 #[test]414 fn math_evaluation() {415 assert_eval!("2 + 2 * 2 == 6");416 assert_eval!("3 + (2 + 2 * 2) == 9");417 }418419 #[test]420 fn string_concat() {421 assert_eval!("'Hello' + 'World' == 'HelloWorld'");422 assert_eval!("'Hello' * 3 == 'HelloHelloHello'");423 assert_eval!("'Hello' + 'World' * 3 == 'HelloWorldWorldWorld'");424 }425426 #[test]427 fn faster_join() {428 assert_eval!("std.join([0,0], [[1,2],[3,4],[5,6]]) == [1,2,0,0,3,4,0,0,5,6]");429 assert_eval!("std.join(',', ['1','2','3','4']) == '1,2,3,4'");430 }431432 #[test]433 fn function_contexts() {434 assert_eval!(435 r#"436 local k = {437 t(name = self.h): [self.h, name],438 h: 3,439 };440 local f = {441 t: k.t(),442 h: 4,443 };444 f.t[0] == f.t[1]445 "#446 );447 }448449 #[test]450 fn local() {451 assert_eval!("local a = 2; local b = 3; a + b == 5");452 assert_eval!("local a = 1, b = a + 1; a + b == 3");453 assert_eval!("local a = 1; local a = 2; a == 2");454 }455456 #[test]457 fn object_lazyness() {458 assert_json!("local a = {a:error 'test'}; {}", r#"{}"#);459 }460461 #[test]462 fn object_inheritance() {463 assert_json!("{a: self.b} + {b:3}", r#"{"a": 3,"b": 3}"#);464 }465466 #[test]467 fn object_assertion_success() {468 eval!("{assert \"a\" in self} + {a:2}");469 }470471 #[test]472 fn object_assertion_error() {473 eval!("{assert \"a\" in self}");474 }475476 #[test]477 fn lazy_args() {478 eval!("local test(a) = 2; test(error '3')");479 }480481 #[test]482 fn tailstrict_args() {483 eval!("local test(a) = 2; test(error '3') tailstrict");484 }485486 #[test]487 fn no_binding_error() {488 eval!("a");489 }490491 #[test]492 fn test_object() {493 assert_json!("{a:2}", r#"{"a": 2}"#);494 assert_json!("{a:2+2}", r#"{"a": 4}"#);495 assert_json!("{a:2}+{b:2}", r#"{"a": 2,"b": 2}"#);496 assert_json!("{b:3}+{b:2}", r#"{"b": 2}"#);497 assert_json!("{b:3}+{b+:2}", r#"{"b": 5}"#);498 assert_json!("local test='a'; {[test]:2}", r#"{"a": 2}"#);499 assert_json!(500 r#"501 {502 name: "Alice",503 welcome: "Hello " + self.name + "!",504 }505 "#,506 r#"{"name": "Alice","welcome": "Hello Alice!"}"#507 );508 assert_json!(509 r#"510 {511 name: "Alice",512 welcome: "Hello " + self.name + "!",513 } + {514 name: "Bob"515 }516 "#,517 r#"{"name": "Bob","welcome": "Hello Bob!"}"#518 );519 }520521 #[test]522 fn functions() {523 assert_json!(r#"local a = function(b, c = 2) b + c; a(2)"#, "4");524 assert_json!(525 r#"local a = function(b, c = "Dear") b + c + d, d = "World"; a("Hello")"#,526 r#""HelloDearWorld""#527 );528 }529530 #[test]531 fn local_methods() {532 assert_json!(r#"local a(b, c = 2) = b + c; a(2)"#, "4");533 assert_json!(534 r#"local a(b, c = "Dear") = b + c + d, d = "World"; a("Hello")"#,535 r#""HelloDearWorld""#536 );537 }538539 #[test]540 fn object_locals() {541 assert_json!(r#"{local a = 3, b: a}"#, r#"{"b": 3}"#);542 assert_json!(r#"{local a = 3, local c = a, b: c}"#, r#"{"b": 3}"#);543 assert_json!(544 r#"{local a = function (b) {[b]:4}, test: a("test")}"#,545 r#"{"test": {"test": 4}}"#546 );547 }548549 #[test]550 fn object_comp() {551 assert_json!(552 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}"#,553 "{\"h1_2\": \"0a\",\"h1_3\": \"0a\",\"h1_4\": \"0a\",\"h2_3\": \"a1\",\"h2_4\": \"a1\",\"h3_2\": \"0a\",\"h3_4\": \"a1\"}"554 )555 }556557 #[test]558 fn direct_self() {559 println!(560 "{:#?}",561 eval!(562 r#"563 {564 local me = self,565 a: 3,566 b(): me.a,567 }568 "#569 )570 );571 }572573 #[test]574 fn indirect_self() {575 576 577 eval!(578 r#"{579 local me = self,580 a: 3,581 b: me.a,582 }.b"#583 );584 }585586 587 #[test]588 fn std_assert_ok() {589 eval!("std.assertEqual(4.5 << 2, 16)");590 }591592 #[test]593 #[should_panic]594 fn std_assert_failure() {595 eval!("std.assertEqual(4.5 << 2, 15)");596 }597598 #[test]599 fn string_is_string() {600 assert_eq!(601 eval!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),602 Val::Bool(false)603 );604 }605606 #[test]607 fn base64_works() {608 assert_json!(r#"std.base64("test")"#, r#""dGVzdA==""#);609 }610611 #[test]612 fn utf8_chars() {613 assert_json!(614 r#"local c="😎";{c:std.codepoint(c),l:std.length(c)}"#,615 r#"{"c": 128526,"l": 1}"#616 )617 }618619 #[test]620 fn json() {621 assert_json!(622 r#"std.manifestJsonEx({a:3, b:4, c:6},"")"#,623 r#""{\n\"a\": 3,\n\"b\": 4,\n\"c\": 6\n}""#624 );625 }626627 #[test]628 fn test() {629 assert_json!(630 r#"[[a, b] for a in [1,2,3] for b in [4,5,6]]"#,631 "[[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]"632 );633 }634635 #[test]636 fn sjsonnet() {637 eval!(638 r#"639 local x0 = {k: 1};640 local x1 = {k: x0.k + x0.k};641 local x2 = {k: x1.k + x1.k};642 local x3 = {k: x2.k + x2.k};643 local x4 = {k: x3.k + x3.k};644 local x5 = {k: x4.k + x4.k};645 local x6 = {k: x5.k + x5.k};646 local x7 = {k: x6.k + x6.k};647 local x8 = {k: x7.k + x7.k};648 local x9 = {k: x8.k + x8.k};649 local x10 = {k: x9.k + x9.k};650 local x11 = {k: x10.k + x10.k};651 local x12 = {k: x11.k + x11.k};652 local x13 = {k: x12.k + x12.k};653 local x14 = {k: x13.k + x13.k};654 local x15 = {k: x14.k + x14.k};655 local x16 = {k: x15.k + x15.k};656 local x17 = {k: x16.k + x16.k};657 local x18 = {k: x17.k + x17.k};658 local x19 = {k: x18.k + x18.k};659 local x20 = {k: x19.k + x19.k};660 local x21 = {k: x20.k + x20.k};661 x21.k662 "#663 );664 }665}