1#![warn(clippy::all, clippy::nursery)]2#![allow(3 macro_expanded_macro_exports_accessed_by_absolute_paths,4 clippy::ptr_arg5)]678extern crate self as jrsonnet_evaluator;910mod builtin;11mod ctx;12mod dynamic;13pub mod error;14mod evaluate;15pub mod function;16mod import;17mod integrations;18mod map;19pub mod native;20mod obj;21pub mod trace;22pub mod typed;23mod val;2425pub use jrsonnet_parser as parser;2627pub use ctx::*;28pub use dynamic::*;29use error::{Error::*, LocError, Result, StackTraceElement};30pub use evaluate::*;31use function::{Builtin, CallLocation, TlaArg};32use gc::{GcHashMap, TraceBox};33use gcmodule::{Cc, Trace, Weak};34pub use import::*;35pub use jrsonnet_interner::IStr;36use jrsonnet_parser::*;37pub use obj::*;38use std::{39 cell::{Ref, RefCell, RefMut},40 collections::HashMap,41 fmt::Debug,42 path::{Path, PathBuf},43 rc::Rc,44};45use trace::{location_to_offset, offset_to_location, CodeLocation, CompactFormat, TraceFormat};46pub use val::*;47pub mod gc;4849pub trait Bindable: Trace + 'static {50 fn bind(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal>;51}5253#[derive(Clone, Trace)]54pub enum LazyBinding {55 Bindable(Cc<TraceBox<dyn Bindable>>),56 Bound(LazyVal),57}5859impl Debug for LazyBinding {60 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {61 write!(f, "LazyBinding")62 }63}64impl LazyBinding {65 pub fn evaluate(&self, this: Option<ObjValue>, super_obj: Option<ObjValue>) -> Result<LazyVal> {66 match self {67 Self::Bindable(v) => v.bind(this, super_obj),68 Self::Bound(v) => Ok(v.clone()),69 }70 }71}7273pub struct EvaluationSettings {74 75 pub max_stack: usize,76 77 pub max_trace: usize,78 79 pub ext_vars: HashMap<IStr, Val>,80 81 pub ext_natives: HashMap<IStr, Cc<TraceBox<dyn Builtin>>>,82 83 pub tla_vars: HashMap<IStr, TlaArg>,84 85 pub globals: HashMap<IStr, Val>,86 87 pub import_resolver: Box<dyn ImportResolver>,88 89 pub manifest_format: ManifestFormat,90 91 pub trace_format: Box<dyn TraceFormat>,92}93impl Default for EvaluationSettings {94 fn default() -> Self {95 Self {96 max_stack: 200,97 max_trace: 20,98 globals: Default::default(),99 ext_vars: Default::default(),100 ext_natives: Default::default(),101 tla_vars: Default::default(),102 import_resolver: Box::new(DummyImportResolver),103 manifest_format: ManifestFormat::Json(4),104 trace_format: Box::new(CompactFormat {105 padding: 4,106 resolver: trace::PathResolver::Absolute,107 }),108 }109 }110}111112#[derive(Default)]113struct EvaluationData {114 115 stack_depth: usize,116 117 stack_generation: usize,118119 breakpoints: Breakpoints,120 121 files: HashMap<Rc<Path>, FileData>,122 str_files: HashMap<Rc<Path>, IStr>,123}124125pub struct FileData {126 source_code: IStr,127 parsed: LocExpr,128 evaluated: Option<Val>,129}130131#[allow(clippy::type_complexity)]132pub struct Breakpoint {133 loc: ExprLocation,134 collected: RefCell<HashMap<usize, (usize, Vec<Result<Val>>)>>,135}136#[derive(Default)]137struct Breakpoints(Vec<Rc<Breakpoint>>);138impl Breakpoints {139 fn insert(140 &self,141 stack_depth: usize,142 stack_generation: usize,143 loc: &ExprLocation,144 result: Result<Val>,145 ) -> Result<Val> {146 if self.0.is_empty() {147 return result;148 }149 for item in self.0.iter() {150 if item.loc.belongs_to(loc) {151 let mut collected = item.collected.borrow_mut();152 let (depth, vals) = collected.entry(stack_generation).or_default();153 if stack_depth > *depth {154 vals.clear();155 }156 vals.push(result.clone());157 }158 }159 result160 }161}162163#[derive(Default)]164pub struct EvaluationStateInternals {165 166 data: RefCell<EvaluationData>,167 168 settings: RefCell<EvaluationSettings>,169}170171thread_local! {172 173 174 pub(crate) static EVAL_STATE: RefCell<Option<EvaluationState>> = RefCell::new(None)175}176177pub(crate) fn with_state<T>(f: impl FnOnce(&EvaluationState) -> T) -> T {178 EVAL_STATE.with(|s| {179 f(s.borrow().as_ref().expect(180 "missing evaluation state, some functions should be called inside of run_in_state call",181 ))182 })183}184pub fn push_frame<T>(185 e: CallLocation,186 frame_desc: impl FnOnce() -> String,187 f: impl FnOnce() -> Result<T>,188) -> Result<T> {189 with_state(|s| s.push(e, frame_desc, f))190}191192#[allow(dead_code)]193pub fn push_val_frame(194 e: &ExprLocation,195 frame_desc: impl FnOnce() -> String,196 f: impl FnOnce() -> Result<Val>,197) -> Result<Val> {198 with_state(|s| s.push_val(e, frame_desc, f))199}200#[allow(dead_code)]201pub fn push_description_frame<T>(202 frame_desc: impl FnOnce() -> String,203 f: impl FnOnce() -> Result<T>,204) -> Result<T> {205 with_state(|s| s.push_description(frame_desc, f))206}207208209#[derive(Default, Clone)]210pub struct EvaluationState(Rc<EvaluationStateInternals>);211212impl EvaluationState {213 214 pub fn add_file(&self, path: Rc<Path>, source_code: IStr) -> Result<LocExpr> {215 let parsed = parse(216 &source_code,217 &ParserSettings {218 file_name: path.clone(),219 },220 )221 .map_err(|error| ImportSyntaxError {222 error: Box::new(error),223 path: path.to_owned(),224 source_code: source_code.clone(),225 })?;226 self.add_parsed_file(path, source_code, parsed.clone())?;227228 Ok(parsed)229 }230231 pub fn reset_evaluation_state(&self, name: &Path) {232 self.data_mut()233 .files234 .get_mut(name)235 .unwrap()236 .evaluated237 .take();238 }239240 241 pub fn add_parsed_file(242 &self,243 name: Rc<Path>,244 source_code: IStr,245 parsed: LocExpr,246 ) -> Result<()> {247 self.data_mut().files.insert(248 name,249 FileData {250 source_code,251 parsed,252 evaluated: None,253 },254 );255256 Ok(())257 }258 pub fn get_source(&self, name: &Path) -> Option<IStr> {259 let ro_map = &self.data().files;260 ro_map.get(name).map(|value| value.source_code.clone())261 }262 pub fn map_source_locations(&self, file: &Path, locs: &[usize]) -> Vec<CodeLocation> {263 offset_to_location(&self.get_source(file).unwrap_or_else(|| "".into()), locs)264 }265 pub fn map_from_source_location(266 &self,267 file: &Path,268 line: usize,269 column: usize,270 ) -> Option<usize> {271 location_to_offset(&self.get_source(file).unwrap(), line, column)272 }273 pub fn import_file(&self, from: &Path, path: &Path) -> Result<Val> {274 let file_path = self.resolve_file(from, path)?;275 {276 let data = self.data();277 let files = &data.files;278 if files.contains_key(&file_path as &Path) {279 drop(data);280 return self.evaluate_loaded_file_raw(&file_path);281 }282 }283 let contents = self.load_file_contents(&file_path)?;284 self.add_file(file_path.clone(), contents)?;285 self.evaluate_loaded_file_raw(&file_path)286 }287 pub(crate) fn import_file_str(&self, from: &Path, path: &Path) -> Result<IStr> {288 let path = self.resolve_file(from, path)?;289 if !self.data().str_files.contains_key(&path) {290 let file_str = self.load_file_contents(&path)?;291 self.data_mut().str_files.insert(path.clone(), file_str);292 }293 Ok(self.data().str_files.get(&path).cloned().unwrap())294 }295296 fn evaluate_loaded_file_raw(&self, name: &Path) -> Result<Val> {297 let expr: LocExpr = {298 let ro_map = &self.data().files;299 let value = ro_map300 .get(name)301 .unwrap_or_else(|| panic!("file not added: {:?}", name));302 if let Some(ref evaluated) = value.evaluated {303 return Ok(evaluated.clone());304 }305 value.parsed.clone()306 };307 let value = evaluate(self.create_default_context(), &expr)?;308 {309 self.data_mut()310 .files311 .get_mut(name)312 .unwrap()313 .evaluated314 .replace(value.clone());315 }316 Ok(value)317 }318319 320 pub fn with_stdlib(&self) -> &Self {321 use jrsonnet_stdlib::STDLIB_STR;322 let std_path: Rc<Path> = PathBuf::from("std.jsonnet").into();323 self.run_in_state(|| {324 self.add_parsed_file(325 std_path.clone(),326 STDLIB_STR.to_owned().into(),327 builtin::get_parsed_stdlib(),328 )329 .unwrap();330 let val = self.evaluate_loaded_file_raw(&std_path).unwrap();331 self.settings_mut().globals.insert("std".into(), val);332 });333 self334 }335336 337 pub fn create_default_context(&self) -> Context {338 let globals = &self.settings().globals;339 let mut new_bindings = GcHashMap::with_capacity(globals.len());340 for (name, value) in globals.iter() {341 new_bindings.insert(name.clone(), LazyVal::new_resolved(value.clone()));342 }343 Context::new().extend_bound(new_bindings)344 }345346 347 pub fn push<T>(348 &self,349 e: CallLocation,350 frame_desc: impl FnOnce() -> String,351 f: impl FnOnce() -> Result<T>,352 ) -> Result<T> {353 {354 let mut data = self.data_mut();355 let stack_depth = &mut data.stack_depth;356 if *stack_depth > self.max_stack() {357 358 drop(data);359 throw!(StackOverflow);360 } else {361 *stack_depth += 1;362 }363 }364 let result = f();365 {366 let mut data = self.data_mut();367 data.stack_depth -= 1;368 data.stack_generation += 1;369 }370 if let Err(mut err) = result {371 err.trace_mut().0.push(StackTraceElement {372 location: e.0.cloned(),373 desc: frame_desc(),374 });375 return Err(err);376 }377 result378 }379380 381 pub fn push_val(382 &self,383 e: &ExprLocation,384 frame_desc: impl FnOnce() -> String,385 f: impl FnOnce() -> Result<Val>,386 ) -> Result<Val> {387 {388 let mut data = self.data_mut();389 let stack_depth = &mut data.stack_depth;390 if *stack_depth > self.max_stack() {391 392 drop(data);393 throw!(StackOverflow);394 } else {395 *stack_depth += 1;396 }397 }398 let mut result = f();399 {400 let mut data = self.data_mut();401 data.stack_depth -= 1;402 data.stack_generation += 1;403 result = data404 .breakpoints405 .insert(data.stack_depth, data.stack_generation, e, result);406 }407 if let Err(mut err) = result {408 err.trace_mut().0.push(StackTraceElement {409 location: Some(e.clone()),410 desc: frame_desc(),411 });412 return Err(err);413 }414 result415 }416 417 pub fn push_description<T>(418 &self,419 frame_desc: impl FnOnce() -> String,420 f: impl FnOnce() -> Result<T>,421 ) -> Result<T> {422 {423 let mut data = self.data_mut();424 let stack_depth = &mut data.stack_depth;425 if *stack_depth > self.max_stack() {426 427 drop(data);428 throw!(StackOverflow);429 } else {430 *stack_depth += 1;431 }432 }433 let result = f();434 {435 let mut data = self.data_mut();436 data.stack_depth -= 1;437 data.stack_generation += 1;438 }439 if let Err(mut err) = result {440 err.trace_mut().0.push(StackTraceElement {441 location: None,442 desc: frame_desc(),443 });444 return Err(err);445 }446 result447 }448449 450 pub fn run_in_state<T>(&self, f: impl FnOnce() -> T) -> T {451 EVAL_STATE.with(|v| {452 let has_state = v.borrow().is_some();453 if !has_state {454 v.borrow_mut().replace(self.clone());455 }456 let result = f();457 if !has_state {458 v.borrow_mut().take();459 }460 result461 })462 }463 pub fn run_in_state_with_breakpoint(464 &self,465 bp: Rc<Breakpoint>,466 f: impl FnOnce() -> Result<()>,467 ) -> Result<()> {468 {469 let mut data = self.data_mut();470 data.breakpoints.0.push(bp);471 }472473 let result = self.run_in_state(f);474475 {476 let mut data = self.data_mut();477 data.breakpoints.0.pop();478 }479480 result481 }482483 pub fn stringify_err(&self, e: &LocError) -> String {484 let mut out = String::new();485 self.settings()486 .trace_format487 .write_trace(&mut out, self, e)488 .unwrap();489 out490 }491492 pub fn manifest(&self, val: Val) -> Result<IStr> {493 self.run_in_state(|| {494 push_description_frame(495 || "manifestification".to_string(),496 || val.manifest(&self.manifest_format()),497 )498 })499 }500 pub fn manifest_multi(&self, val: Val) -> Result<Vec<(IStr, IStr)>> {501 self.run_in_state(|| val.manifest_multi(&self.manifest_format()))502 }503 pub fn manifest_stream(&self, val: Val) -> Result<Vec<IStr>> {504 self.run_in_state(|| val.manifest_stream(&self.manifest_format()))505 }506507 508 pub fn with_tla(&self, val: Val) -> Result<Val> {509 self.run_in_state(|| {510 Ok(match val {511 Val::Func(func) => push_description_frame(512 || "during TLA call".to_owned(),513 || {514 func.evaluate(515 self.create_default_context(),516 CallLocation::native(),517 &self.settings().tla_vars,518 true,519 )520 },521 )?,522 v => v,523 })524 })525 }526}527528529impl EvaluationState {530 fn data(&self) -> Ref<EvaluationData> {531 self.0.data.borrow()532 }533 fn data_mut(&self) -> RefMut<EvaluationData> {534 self.0.data.borrow_mut()535 }536 pub fn settings(&self) -> Ref<EvaluationSettings> {537 self.0.settings.borrow()538 }539 pub fn settings_mut(&self) -> RefMut<EvaluationSettings> {540 self.0.settings.borrow_mut()541 }542}543544545impl EvaluationState {546 pub fn evaluate_file_raw(&self, name: &Path) -> Result<Val> {547 self.run_in_state(|| self.import_file(&std::env::current_dir().expect("cwd"), name))548 }549 pub fn evaluate_file_raw_nocwd(&self, name: &Path) -> Result<Val> {550 self.run_in_state(|| self.import_file(&PathBuf::from("."), name))551 }552 553 pub fn evaluate_snippet_raw(&self, source: Rc<Path>, code: IStr) -> Result<Val> {554 let parsed = parse(555 &code,556 &ParserSettings {557 file_name: source.clone(),558 },559 )560 .map_err(|e| ImportSyntaxError {561 path: source.clone(),562 source_code: code.clone(),563 error: Box::new(e),564 })?;565 self.add_parsed_file(source, code, parsed.clone())?;566 self.evaluate_expr_raw(parsed)567 }568 569 pub fn evaluate_expr_raw(&self, code: LocExpr) -> Result<Val> {570 self.run_in_state(|| evaluate(self.create_default_context(), &code))571 }572}573574575impl EvaluationState {576 pub fn add_ext_var(&self, name: IStr, value: Val) {577 self.settings_mut().ext_vars.insert(name, value);578 }579 pub fn add_ext_str(&self, name: IStr, value: IStr) {580 self.add_ext_var(name, Val::Str(value));581 }582 pub fn add_ext_code(&self, name: IStr, code: IStr) -> Result<()> {583 let value =584 self.evaluate_snippet_raw(PathBuf::from(format!("ext_code {}", name)).into(), code)?;585 self.add_ext_var(name, value);586 Ok(())587 }588589 pub fn add_tla(&self, name: IStr, value: Val) {590 self.settings_mut()591 .tla_vars592 .insert(name, TlaArg::Val(value));593 }594 pub fn add_tla_str(&self, name: IStr, value: IStr) {595 self.settings_mut()596 .tla_vars597 .insert(name, TlaArg::String(value));598 }599 pub fn add_tla_code(&self, name: IStr, code: IStr) -> Result<()> {600 let parsed = self.add_file(PathBuf::from(format!("tla_code {}", name)).into(), code)?;601 self.settings_mut()602 .tla_vars603 .insert(name, TlaArg::Code(parsed));604 Ok(())605 }606607 pub fn resolve_file(&self, from: &Path, path: &Path) -> Result<Rc<Path>> {608 self.settings().import_resolver.resolve_file(from, path)609 }610 pub fn load_file_contents(&self, path: &Path) -> Result<IStr> {611 self.settings().import_resolver.load_file_contents(path)612 }613614 pub fn import_resolver(&self) -> Ref<dyn ImportResolver> {615 Ref::map(self.settings(), |s| &*s.import_resolver)616 }617 pub fn set_import_resolver(&self, resolver: Box<dyn ImportResolver>) {618 self.settings_mut().import_resolver = resolver;619 }620621 pub fn add_native(&self, name: IStr, cb: Cc<TraceBox<dyn Builtin>>) {622 self.settings_mut().ext_natives.insert(name, cb);623 }624625 pub fn manifest_format(&self) -> ManifestFormat {626 self.settings().manifest_format.clone()627 }628 pub fn set_manifest_format(&self, format: ManifestFormat) {629 self.settings_mut().manifest_format = format;630 }631632 pub fn trace_format(&self) -> Ref<dyn TraceFormat> {633 Ref::map(self.settings(), |s| &*s.trace_format)634 }635 pub fn set_trace_format(&self, format: Box<dyn TraceFormat>) {636 self.settings_mut().trace_format = format;637 }638639 pub fn max_trace(&self) -> usize {640 self.settings().max_trace641 }642 pub fn set_max_trace(&self, trace: usize) {643 self.settings_mut().max_trace = trace;644 }645646 pub fn max_stack(&self) -> usize {647 self.settings().max_stack648 }649 pub fn set_max_stack(&self, trace: usize) {650 self.settings_mut().max_stack = trace;651 }652}653654pub fn cc_ptr_eq<T>(a: &Cc<T>, b: &Cc<T>) -> bool {655 let a = a as &T;656 let b = b as &T;657 std::ptr::eq(a, b)658}659660fn weak_raw<T>(a: Weak<T>) -> *const () {661 unsafe { std::mem::transmute(a) }662}663fn weak_ptr_eq<T>(a: Weak<T>, b: Weak<T>) -> bool {664 std::ptr::eq(weak_raw(a), weak_raw(b))665}666667#[test]668fn weak_unsafe() {669 let a = Cc::new(1);670 let b = Cc::new(2);671672 let aw1 = a.clone().downgrade();673 let aw2 = a.clone().downgrade();674 let aw3 = a.clone().downgrade();675676 let bw = b.clone().downgrade();677678 assert!(weak_ptr_eq(aw1, aw2));679 assert!(!weak_ptr_eq(aw3, bw));680}681682#[cfg(test)]683pub mod tests {684 use super::Val;685 use crate::{686 error::Error::*, function::BuiltinParam, gc::TraceBox, native::NativeCallbackHandler,687 primitive_equals, EvaluationState,688 };689 use gcmodule::{Cc, Trace};690 use jrsonnet_interner::IStr;691 use jrsonnet_parser::*;692 use std::{693 path::{Path, PathBuf},694 rc::Rc,695 };696697 #[test]698 #[should_panic]699 fn eval_state_stacktrace() {700 let state = EvaluationState::default();701 state.run_in_state(|| {702 state703 .push(704 Some(&ExprLocation(PathBuf::from("test1.jsonnet").into(), 10, 20)),705 || "outer".to_owned(),706 || {707 state.push(708 Some(&ExprLocation(PathBuf::from("test2.jsonnet").into(), 30, 40)),709 || "inner".to_owned(),710 || Err(RuntimeError("".into()).into()),711 )?;712 Ok(Val::Null)713 },714 )715 .unwrap();716 });717 }718719 #[test]720 fn eval_state_standard() {721 let state = EvaluationState::default();722 state.with_stdlib();723 assert!(primitive_equals(724 &state725 .evaluate_snippet_raw(726 PathBuf::from("raw.jsonnet").into(),727 r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#.into()728 )729 .unwrap(),730 &Val::Bool(true),731 )732 .unwrap());733 }734735 macro_rules! eval {736 ($str: expr) => {{737 let evaluator = EvaluationState::default();738 evaluator.with_stdlib();739 evaluator.run_in_state(|| {740 evaluator741 .evaluate_snippet_raw(PathBuf::from("raw.jsonnet").into(), $str.into())742 .unwrap()743 })744 }};745 }746 macro_rules! eval_json {747 ($str: expr) => {{748 let evaluator = EvaluationState::default();749 evaluator.with_stdlib();750 evaluator.run_in_state(|| {751 evaluator752 .evaluate_snippet_raw(PathBuf::from("raw.jsonnet").into(), $str.into())753 .unwrap()754 .to_json(0)755 .unwrap()756 .replace("\n", "")757 })758 }};759 }760761 762 macro_rules! assert_eval {763 ($str: expr) => {764 assert!(primitive_equals(&eval!($str), &Val::Bool(true)).unwrap())765 };766 }767768 769 macro_rules! assert_eval_neg {770 ($str: expr) => {771 assert!(primitive_equals(&eval!($str), &Val::Bool(false)).unwrap())772 };773 }774 macro_rules! assert_json {775 ($str: expr, $out: expr) => {776 assert_eq!(eval_json!($str), $out.replace("\t", ""))777 };778 }779780 781 #[test]782 fn equality_operator() {783 assert_eval!("2 == 2");784 assert_eval_neg!("2 != 2");785 assert_eval!("2 != 3");786 assert_eval_neg!("2 == 3");787 assert_eval!("'Hello' == 'Hello'");788 assert_eval_neg!("'Hello' != 'Hello'");789 assert_eval!("'Hello' != 'World'");790 assert_eval_neg!("'Hello' == 'World'");791 }792793 #[test]794 fn math_evaluation() {795 assert_eval!("2 + 2 * 2 == 6");796 assert_eval!("3 + (2 + 2 * 2) == 9");797 }798799 #[test]800 fn string_concat() {801 assert_eval!("'Hello' + 'World' == 'HelloWorld'");802 assert_eval!("'Hello' * 3 == 'HelloHelloHello'");803 assert_eval!("'Hello' + 'World' * 3 == 'HelloWorldWorldWorld'");804 }805806 #[test]807 fn faster_join() {808 assert_eval!("std.join([0,0], [[1,2],[3,4],[5,6]]) == [1,2,0,0,3,4,0,0,5,6]");809 assert_eval!("std.join(',', ['1','2','3','4']) == '1,2,3,4'");810 }811812 #[test]813 fn function_contexts() {814 assert_eval!(815 r#"816 local k = {817 t(name = self.h): [self.h, name],818 h: 3,819 };820 local f = {821 t: k.t(),822 h: 4,823 };824 f.t[0] == f.t[1]825 "#826 );827 }828829 #[test]830 fn local() {831 assert_eval!("local a = 2; local b = 3; a + b == 5");832 assert_eval!("local a = 1, b = a + 1; a + b == 3");833 assert_eval!("local a = 1; local a = 2; a == 2");834 }835836 #[test]837 fn object_lazyness() {838 assert_json!("local a = {a:error 'test'}; {}", r#"{}"#);839 }840841 #[test]842 fn object_inheritance() {843 assert_json!("{a: self.b} + {b:3}", r#"{"a": 3,"b": 3}"#);844 }845846 #[test]847 fn object_assertion_success() {848 eval!("{assert \"a\" in self} + {a:2}");849 }850851 #[test]852 fn object_assertion_error() {853 eval!("{assert \"a\" in self}");854 }855856 #[test]857 fn lazy_args() {858 eval!("local test(a) = 2; test(error '3')");859 }860861 #[test]862 #[should_panic]863 fn tailstrict_args() {864 eval!("local test(a) = 2; test(error '3') tailstrict");865 }866867 #[test]868 #[should_panic]869 fn no_binding_error() {870 eval!("a");871 }872873 #[test]874 fn test_object() {875 assert_json!("{a:2}", r#"{"a": 2}"#);876 assert_json!("{a:2+2}", r#"{"a": 4}"#);877 assert_json!("{a:2}+{b:2}", r#"{"a": 2,"b": 2}"#);878 assert_json!("{b:3}+{b:2}", r#"{"b": 2}"#);879 assert_json!("{b:3}+{b+:2}", r#"{"b": 5}"#);880 assert_json!("local test='a'; {[test]:2}", r#"{"a": 2}"#);881 assert_json!(882 r#"883 {884 name: "Alice",885 welcome: "Hello " + self.name + "!",886 }887 "#,888 r#"{"name": "Alice","welcome": "Hello Alice!"}"#889 );890 assert_json!(891 r#"892 {893 name: "Alice",894 welcome: "Hello " + self.name + "!",895 } + {896 name: "Bob"897 }898 "#,899 r#"{"name": "Bob","welcome": "Hello Bob!"}"#900 );901 }902903 #[test]904 fn functions() {905 assert_json!(r#"local a = function(b, c = 2) b + c; a(2)"#, "4");906 assert_json!(907 r#"local a = function(b, c = "Dear") b + c + d, d = "World"; a("Hello")"#,908 r#""HelloDearWorld""#909 );910 }911912 #[test]913 fn local_methods() {914 assert_json!(r#"local a(b, c = 2) = b + c; a(2)"#, "4");915 assert_json!(916 r#"local a(b, c = "Dear") = b + c + d, d = "World"; a("Hello")"#,917 r#""HelloDearWorld""#918 );919 }920921 #[test]922 fn object_locals() {923 assert_json!(r#"{local a = 3, b: a}"#, r#"{"b": 3}"#);924 assert_json!(r#"{local a = 3, local c = a, b: c}"#, r#"{"b": 3}"#);925 assert_json!(926 r#"{local a = function (b) {[b]:4}, test: a("test")}"#,927 r#"{"test": {"test": 4}}"#928 );929 }930931 #[test]932 fn object_comp() {933 assert_json!(934 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}"#,935 "{\"h1_2\": \"0a\",\"h1_3\": \"0a\",\"h1_4\": \"0a\",\"h2_3\": \"a1\",\"h2_4\": \"a1\",\"h3_2\": \"0a\",\"h3_4\": \"a1\"}"936 )937 }938939 #[test]940 fn direct_self() {941 println!(942 "{:#?}",943 eval!(944 r#"945 {946 local me = self,947 a: 3,948 b(): me.a,949 }950 "#951 )952 );953 }954955 #[test]956 fn indirect_self() {957 958 959 eval!(960 r#"{961 local me = self,962 a: 3,963 b: me.a,964 }.b"#965 );966 }967968 969 #[test]970 fn std_assert_ok() {971 eval!("std.assertEqual(4.5 << 2, 16)");972 }973974 #[test]975 #[should_panic]976 fn std_assert_failure() {977 eval!("std.assertEqual(4.5 << 2, 15)");978 }979980 #[test]981 fn string_is_string() {982 assert!(primitive_equals(983 &eval!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),984 &Val::Bool(false),985 )986 .unwrap());987 }988989 #[test]990 fn base64_works() {991 assert_json!(r#"std.base64("test")"#, r#""dGVzdA==""#);992 }993994 #[test]995 fn utf8_chars() {996 assert_json!(997 r#"local c="😎";{c:std.codepoint(c),l:std.length(c)}"#,998 r#"{"c": 128526,"l": 1}"#999 )1000 }10011002 #[test]1003 fn json() {1004 assert_json!(1005 r#"std.manifestJsonEx({a:3, b:4, c:6},"")"#,1006 r#""{\n\"a\": 3,\n\"b\": 4,\n\"c\": 6\n}""#1007 );1008 }10091010 #[test]1011 fn json_minified() {1012 assert_json!(1013 r#"std.manifestJsonMinified({a:3, b:4, c:6})"#,1014 r#""{\"a\":3,\"b\":4,\"c\":6}""#1015 );1016 }10171018 #[test]1019 fn parse_json() {1020 assert_json!(1021 r#"std.parseJson('{"a": -1,"b": 1,"c": 3.141,"d": []}')"#,1022 r#"{"a": -1,"b": 1,"c": 3.141,"d": []}"#1023 );1024 }10251026 #[test]1027 fn test() {1028 assert_json!(1029 r#"[[a, b] for a in [1,2,3] for b in [4,5,6]]"#,1030 "[[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]"1031 );1032 }10331034 #[test]1035 fn sjsonnet() {1036 eval!(1037 r#"1038 local x0 = {k: 1};1039 local x1 = {k: x0.k + x0.k};1040 local x2 = {k: x1.k + x1.k};1041 local x3 = {k: x2.k + x2.k};1042 local x4 = {k: x3.k + x3.k};1043 local x5 = {k: x4.k + x4.k};1044 local x6 = {k: x5.k + x5.k};1045 local x7 = {k: x6.k + x6.k};1046 local x8 = {k: x7.k + x7.k};1047 local x9 = {k: x8.k + x8.k};1048 local x10 = {k: x9.k + x9.k};1049 local x11 = {k: x10.k + x10.k};1050 local x12 = {k: x11.k + x11.k};1051 local x13 = {k: x12.k + x12.k};1052 local x14 = {k: x13.k + x13.k};1053 local x15 = {k: x14.k + x14.k};1054 local x16 = {k: x15.k + x15.k};1055 local x17 = {k: x16.k + x16.k};1056 local x18 = {k: x17.k + x17.k};1057 local x19 = {k: x18.k + x18.k};1058 local x20 = {k: x19.k + x19.k};1059 local x21 = {k: x20.k + x20.k};1060 x21.k1061 "#1062 );1063 }10641065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 10771078 10791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104 #[test]1105 fn equality() {1106 println!(1107 "{:?}",1108 jrsonnet_parser::parse(1109 "{ x: 1, y: 2 } == { x: 1, y: 2 }",1110 &ParserSettings {1111 file_name: PathBuf::from("equality").into(),1112 }1113 )1114 );1115 assert_eval!("{ x: 1, y: 2 } == { x: 1, y: 2 }")1116 }11171118 #[test]1119 fn native_ext() -> crate::error::Result<()> {1120 use super::native::NativeCallback;1121 let evaluator = EvaluationState::default();11221123 evaluator.with_stdlib();11241125 #[derive(Trace)]1126 struct NativeAdd;1127 impl NativeCallbackHandler for NativeAdd {1128 fn call(&self, from: Option<Rc<Path>>, args: &[Val]) -> crate::error::Result<Val> {1129 assert_eq!(1130 &from.unwrap() as &Path,1131 &PathBuf::from("native_caller.jsonnet")1132 );1133 match (&args[0], &args[1]) {1134 (Val::Num(a), Val::Num(b)) => Ok(Val::Num(a + b)),1135 (_, _) => unreachable!(),1136 }1137 }1138 }1139 evaluator.settings_mut().ext_natives.insert(1140 "native_add".into(),1141 #[allow(deprecated)]1142 Cc::new(TraceBox(Box::new(NativeCallback::new(1143 vec![1144 BuiltinParam {1145 name: "a".into(),1146 has_default: false,1147 },1148 BuiltinParam {1149 name: "b".into(),1150 has_default: false,1151 },1152 ],1153 TraceBox(Box::new(NativeAdd)),1154 )))),1155 );1156 evaluator.evaluate_snippet_raw(1157 PathBuf::from("native_caller.jsonnet").into(),1158 "std.assertEqual(std.native(\"native_add\")(1, 2), 3)".into(),1159 )?;1160 Ok(())1161 }11621163 #[test]1164 fn constant_intrinsic() -> crate::error::Result<()> {1165 assert_eval!(1166 "local std2 = std; local std = std2 { primitiveEquals(a, b):: false }; 1 == 1"1167 );1168 Ok(())1169 }11701171 #[test]1172 fn standalone_super() -> crate::error::Result<()> {1173 assert_eval!(1174 r#"1175 local obj = {1176 a: 1,1177 b: 2,1178 c: 3,1179 };1180 local test = obj + {1181 fields: std.objectFields(super),1182 d: 5,1183 };1184 test.fields == ['a', 'b', 'c']1185 "#1186 );1187 Ok(())1188 }11891190 #[test]1191 fn comp_self() -> crate::error::Result<()> {1192 assert_eval!(1193 r#"1194 std.objectFields({1195 a:{1196 [name]: name for name in std.objectFields(self)1197 },1198 b: 2,1199 c: 3,1200 }.a) == ['a', 'b', 'c']1201 "#1202 );12031204 Ok(())1205 }12061207 struct TestImportResolver(IStr);1208 impl crate::import::ImportResolver for TestImportResolver {1209 fn resolve_file(&self, _: &Path, _: &Path) -> crate::error::Result<Rc<Path>> {1210 Ok(PathBuf::from("/test").into())1211 }12121213 fn load_file_contents(&self, _: &Path) -> crate::error::Result<IStr> {1214 Ok(self.0.clone())1215 }12161217 unsafe fn as_any(&self) -> &dyn std::any::Any {1218 panic!()1219 }1220 }12211222 #[test]1223 fn issue_23() {1224 let state = EvaluationState::default();1225 state.set_import_resolver(Box::new(TestImportResolver(r#"import "/test""#.into())));1226 let _ = state.evaluate_file_raw(&PathBuf::from("/test"));1227 }12281229 #[test]1230 fn issue_40() {1231 let state = EvaluationState::default();1232 state.with_stdlib();12331234 let error = state1235 .evaluate_snippet_raw(1236 PathBuf::from("issue40.jsonnet").into(),1237 r#"1238 local conf = {1239 n: ""1240 };12411242 local result = conf + {1243 assert std.isNumber(self.n): "is number"1244 };12451246 std.manifestJsonEx(result, "")1247 "#1248 .into(),1249 )1250 .unwrap_err();1251 assert_eq!(error.error().to_string(), "assert failed: is number");1252 }12531254 #[test]1255 fn test_ascii_upper_lower() {1256 assert_eval!(r#"std.assertEqual(std.asciiUpper("aBc😀"), "ABC😀")"#);1257 assert_eval!(r#"std.assertEqual(std.asciiLower("aBc😀"), "abc😀")"#);1258 }12591260 #[test]1261 fn test_member() {1262 assert_eval!(r#"!std.member("", "")"#);1263 assert_eval!(r#"std.member("abc", "a")"#);1264 assert_eval!(r#"!std.member("abc", "d")"#);1265 assert_eval!(r#"!std.member([], "")"#);1266 assert_eval!(r#"std.member(["a", "b", "c"], "a")"#);1267 assert_eval!(r#"!std.member(["a", "b", "c"], "d")"#);1268 }12691270 #[test]1271 fn test_count() {1272 assert_eval!(r#"std.assertEqual(std.count([], ""), 0)"#);1273 assert_eval!(r#"std.assertEqual(std.count(["a", "b", "a"], "d"), 0)"#);1274 assert_eval!(r#"std.assertEqual(std.count(["a", "b", "a"], "a"), 2)"#);1275 }12761277 mod derive_typed {1278 use crate::{typed::Typed, EvaluationState};1279 use std::path::PathBuf;12801281 #[derive(Typed, PartialEq, Debug)]1282 struct MyTyped {1283 a: u32,1284 #[typed(rename = "b")]1285 c: String,1286 }12871288 #[test]1289 fn test() {1290 let es = EvaluationState::default();1291 let val = eval!("{a: 14, b: 'Hello, world!'}");1292 let typed = es.run_in_state(|| MyTyped::try_from(val).unwrap());12931294 assert_eq!(1295 typed,1296 MyTyped {1297 a: 14,1298 c: "Hello, world!".to_string()1299 }1300 );1301 es.settings_mut().globals.insert(1302 "mytyped".into(),1303 es.run_in_state(|| typed.try_into()).unwrap(),1304 );13051306 let v = es1307 .evaluate_snippet_raw(1308 PathBuf::from("raw.jsonnet").into(),1309 "1310 mytyped == {a: 14, b: 'Hello, world!'}1311 "1312 .into(),1313 )1314 .unwrap()1315 .as_bool()1316 .unwrap();1317 assert!(v)1318 }1319 }1320}