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.into());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 evaluator394 .parse_evaluate_raw($str)395 .unwrap()396 .into_json(0)397 .unwrap()398 .replace("\n", "")399 }};400 }401402 403 macro_rules! assert_eval {404 ($str: expr) => {405 assert_eq!(eval!($str), Val::Bool(true))406 };407 }408409 410 macro_rules! assert_eval_neg {411 ($str: expr) => {412 assert_eq!(eval!($str), Val::Bool(false))413 };414 }415 macro_rules! assert_json {416 ($str: expr, $out: expr) => {417 assert_eq!(eval_json!($str), $out.replace("\t", ""))418 };419 }420421 422 #[test]423 fn equality_operator() {424 assert_eval!("2 == 2");425 assert_eval_neg!("2 != 2");426 assert_eval!("2 != 3");427 assert_eval_neg!("2 == 3");428 assert_eval!("'Hello' == 'Hello'");429 assert_eval_neg!("'Hello' != 'Hello'");430 assert_eval!("'Hello' != 'World'");431 assert_eval_neg!("'Hello' == 'World'");432 }433434 #[test]435 fn math_evaluation() {436 assert_eval!("2 + 2 * 2 == 6");437 assert_eval!("3 + (2 + 2 * 2) == 9");438 }439440 #[test]441 fn string_concat() {442 assert_eval!("'Hello' + 'World' == 'HelloWorld'");443 assert_eval!("'Hello' * 3 == 'HelloHelloHello'");444 assert_eval!("'Hello' + 'World' * 3 == 'HelloWorldWorldWorld'");445 }446447 #[test]448 fn faster_join() {449 assert_eval!("std.join([0,0], [[1,2],[3,4],[5,6]]) == [1,2,0,0,3,4,0,0,5,6]");450 assert_eval!("std.join(',', ['1','2','3','4']) == '1,2,3,4'");451 }452453 #[test]454 fn function_contexts() {455 assert_eval!(456 r#"457 local k = {458 t(name = self.h): [self.h, name],459 h: 3,460 };461 local f = {462 t: k.t(),463 h: 4,464 };465 f.t[0] == f.t[1]466 "#467 );468 }469470 #[test]471 fn local() {472 assert_eval!("local a = 2; local b = 3; a + b == 5");473 assert_eval!("local a = 1, b = a + 1; a + b == 3");474 assert_eval!("local a = 1; local a = 2; a == 2");475 }476477 #[test]478 fn object_lazyness() {479 assert_json!("local a = {a:error 'test'}; {}", r#"{}"#);480 }481482 #[test]483 fn object_inheritance() {484 assert_json!("{a: self.b} + {b:3}", r#"{"a": 3,"b": 3}"#);485 }486487 #[test]488 fn object_assertion_success() {489 eval!("{assert \"a\" in self} + {a:2}");490 }491492 #[test]493 fn object_assertion_error() {494 eval!("{assert \"a\" in self}");495 }496497 #[test]498 fn lazy_args() {499 eval!("local test(a) = 2; test(error '3')");500 }501502 #[test]503 fn tailstrict_args() {504 eval!("local test(a) = 2; test(error '3') tailstrict");505 }506507 #[test]508 fn no_binding_error() {509 eval!("a");510 }511512 #[test]513 fn test_object() {514 assert_json!("{a:2}", r#"{"a": 2}"#);515 assert_json!("{a:2+2}", r#"{"a": 4}"#);516 assert_json!("{a:2}+{b:2}", r#"{"a": 2,"b": 2}"#);517 assert_json!("{b:3}+{b:2}", r#"{"b": 2}"#);518 assert_json!("{b:3}+{b+:2}", r#"{"b": 5}"#);519 assert_json!("local test='a'; {[test]:2}", r#"{"a": 2}"#);520 assert_json!(521 r#"522 {523 name: "Alice",524 welcome: "Hello " + self.name + "!",525 }526 "#,527 r#"{"name": "Alice","welcome": "Hello Alice!"}"#528 );529 assert_json!(530 r#"531 {532 name: "Alice",533 welcome: "Hello " + self.name + "!",534 } + {535 name: "Bob"536 }537 "#,538 r#"{"name": "Bob","welcome": "Hello Bob!"}"#539 );540 }541542 #[test]543 fn functions() {544 assert_json!(r#"local a = function(b, c = 2) b + c; a(2)"#, "4");545 assert_json!(546 r#"local a = function(b, c = "Dear") b + c + d, d = "World"; a("Hello")"#,547 r#""HelloDearWorld""#548 );549 }550551 #[test]552 fn local_methods() {553 assert_json!(r#"local a(b, c = 2) = b + c; a(2)"#, "4");554 assert_json!(555 r#"local a(b, c = "Dear") = b + c + d, d = "World"; a("Hello")"#,556 r#""HelloDearWorld""#557 );558 }559560 #[test]561 fn object_locals() {562 assert_json!(r#"{local a = 3, b: a}"#, r#"{"b": 3}"#);563 assert_json!(r#"{local a = 3, local c = a, b: c}"#, r#"{"b": 3}"#);564 assert_json!(565 r#"{local a = function (b) {[b]:4}, test: a("test")}"#,566 r#"{"test": {"test": 4}}"#567 );568 }569570 #[test]571 fn object_comp() {572 assert_json!(573 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}"#,574 "{\"h1_2\": \"0a\",\"h1_3\": \"0a\",\"h1_4\": \"0a\",\"h2_3\": \"a1\",\"h2_4\": \"a1\",\"h3_2\": \"0a\",\"h3_4\": \"a1\"}"575 )576 }577578 #[test]579 fn direct_self() {580 println!(581 "{:#?}",582 eval!(583 r#"584 {585 local me = self,586 a: 3,587 b(): me.a,588 }589 "#590 )591 );592 }593594 #[test]595 fn indirect_self() {596 597 598 eval!(599 r#"{600 local me = self,601 a: 3,602 b: me.a,603 }.b"#604 );605 }606607 608 #[test]609 fn std_assert_ok() {610 eval!("std.assertEqual(4.5 << 2, 16)");611 }612613 #[test]614 #[should_panic]615 fn std_assert_failure() {616 eval!("std.assertEqual(4.5 << 2, 15)");617 }618619 #[test]620 fn string_is_string() {621 assert_eq!(622 eval!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),623 Val::Bool(false)624 );625 }626627 #[test]628 fn base64_works() {629 assert_json!(r#"std.base64("test")"#, r#""dGVzdA==""#);630 }631632 #[test]633 fn utf8_chars() {634 assert_json!(635 r#"local c="😎";{c:std.codepoint(c),l:std.length(c)}"#,636 r#"{"c": 128526,"l": 1}"#637 )638 }639640 #[test]641 fn json() {642 assert_json!(643 r#"std.manifestJsonEx({a:3, b:4, c:6},"")"#,644 r#""{\n\"a\": 3,\n\"b\": 4,\n\"c\": 6\n}""#645 );646 }647648 #[test]649 fn test() {650 assert_json!(651 r#"[[a, b] for a in [1,2,3] for b in [4,5,6]]"#,652 "[[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]"653 );654 }655656 #[test]657 fn sjsonnet() {658 eval!(659 r#"660 local x0 = {k: 1};661 local x1 = {k: x0.k + x0.k};662 local x2 = {k: x1.k + x1.k};663 local x3 = {k: x2.k + x2.k};664 local x4 = {k: x3.k + x3.k};665 local x5 = {k: x4.k + x4.k};666 local x6 = {k: x5.k + x5.k};667 local x7 = {k: x6.k + x6.k};668 local x8 = {k: x7.k + x7.k};669 local x9 = {k: x8.k + x8.k};670 local x10 = {k: x9.k + x9.k};671 local x11 = {k: x10.k + x10.k};672 local x12 = {k: x11.k + x11.k};673 local x13 = {k: x12.k + x12.k};674 local x14 = {k: x13.k + x13.k};675 local x15 = {k: x14.k + x14.k};676 local x16 = {k: x15.k + x15.k};677 local x17 = {k: x16.k + x16.k};678 local x18 = {k: x17.k + x17.k};679 local x19 = {k: x18.k + x18.k};680 local x20 = {k: x19.k + x19.k};681 local x21 = {k: x20.k + x20.k};682 x21.k683 "#684 );685 }686687 use test::Bencher;688689 690 691 692 693 694 695 696 697 698 699 700 701702 #[bench]703 fn bench_serialize(b: &mut Bencher) {704 b.iter(|| {705 bincode::deserialize::<jsonnet_parser::LocExpr>(include_bytes!(concat!(706 env!("OUT_DIR"),707 "/stdlib.bincode"708 )))709 .expect("deserialize stdlib")710 })711 }712713 #[bench]714 fn bench_parse(b: &mut Bencher) {715 b.iter(|| {716 jsonnet_parser::parse(717 jsonnet_stdlib::STDLIB_STR,718 &jsonnet_parser::ParserSettings {719 loc_data: true,720 file_name: Rc::new(PathBuf::from("std.jsonnet")),721 },722 )723 })724 }725}