1#![warn(clippy::all, clippy::nursery, clippy::pedantic)]2#![allow(3 macro_expanded_macro_exports_accessed_by_absolute_paths,4 clippy::ptr_arg,5 6 clippy::must_use_candidate,7 8 clippy::missing_errors_doc,9 10 clippy::needless_pass_by_value,11 12 clippy::wildcard_imports,13 clippy::enum_glob_use,14 clippy::module_name_repetitions,15 16 clippy::cast_precision_loss,17 clippy::cast_possible_wrap,18 clippy::cast_possible_truncation,19 clippy::cast_sign_loss,20)]212223extern crate self as jrsonnet_evaluator;2425mod builtin;26mod ctx;27mod dynamic;28pub mod error;29mod evaluate;30pub mod function;31pub mod gc;32mod import;33mod integrations;34mod map;35pub mod native;36mod obj;37pub mod trace;38pub mod typed;39pub mod val;4041use std::{42 cell::{Ref, RefCell, RefMut},43 collections::HashMap,44 fmt::Debug,45 path::{Path, PathBuf},46 rc::Rc,47};4849pub use ctx::*;50pub use dynamic::*;51use error::{Error::*, LocError, Result, StackTraceElement};52pub use evaluate::*;53use function::{Builtin, CallLocation, TlaArg};54use gc::{GcHashMap, TraceBox};55use gcmodule::{Cc, Trace, Weak};56pub use import::*;57pub use jrsonnet_interner::IStr;58pub use jrsonnet_parser as parser;59use jrsonnet_parser::*;60pub use obj::*;61use trace::{location_to_offset, offset_to_location, CodeLocation, CompactFormat, TraceFormat};62pub use val::{LazyVal, ManifestFormat, Val};6364pub trait Bindable: Trace + 'static {65 fn bind(66 &self,67 s: State,68 this: Option<ObjValue>,69 super_obj: Option<ObjValue>,70 ) -> Result<LazyVal>;71}7273#[derive(Clone, Trace)]74pub enum LazyBinding {75 Bindable(Cc<TraceBox<dyn Bindable>>),76 Bound(LazyVal),77}7879impl Debug for LazyBinding {80 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {81 write!(f, "LazyBinding")82 }83}84impl LazyBinding {85 pub fn evaluate(86 &self,87 s: State,88 this: Option<ObjValue>,89 super_obj: Option<ObjValue>,90 ) -> Result<LazyVal> {91 match self {92 Self::Bindable(v) => v.bind(s, this, super_obj),93 Self::Bound(v) => Ok(v.clone()),94 }95 }96}9798pub struct EvaluationSettings {99 100 pub max_stack: usize,101 102 pub max_trace: usize,103 104 pub ext_vars: HashMap<IStr, Val>,105 106 pub ext_natives: HashMap<IStr, Cc<TraceBox<dyn Builtin>>>,107 108 pub tla_vars: HashMap<IStr, TlaArg>,109 110 pub globals: HashMap<IStr, Val>,111 112 pub import_resolver: Box<dyn ImportResolver>,113 114 pub manifest_format: ManifestFormat,115 116 pub trace_format: Box<dyn TraceFormat>,117}118impl Default for EvaluationSettings {119 fn default() -> Self {120 Self {121 max_stack: 200,122 max_trace: 20,123 globals: HashMap::default(),124 ext_vars: HashMap::default(),125 ext_natives: HashMap::default(),126 tla_vars: HashMap::default(),127 import_resolver: Box::new(DummyImportResolver),128 manifest_format: ManifestFormat::Json {129 padding: 4,130 #[cfg(feature = "exp-preserve-order")]131 preserve_order: false,132 },133 trace_format: Box::new(CompactFormat {134 padding: 4,135 resolver: trace::PathResolver::Absolute,136 }),137 }138 }139}140141#[derive(Default)]142struct EvaluationData {143 144 stack_depth: usize,145 146 stack_generation: usize,147148 breakpoints: Breakpoints,149 150 files: GcHashMap<Rc<Path>, FileData>,151 str_files: GcHashMap<Rc<Path>, IStr>,152 bin_files: GcHashMap<Rc<Path>, Rc<[u8]>>,153}154155pub struct FileData {156 source_code: IStr,157 parsed: LocExpr,158 evaluated: Option<Val>,159}160161#[allow(clippy::type_complexity)]162pub struct Breakpoint {163 loc: ExprLocation,164 collected: RefCell<HashMap<usize, (usize, Vec<Result<Val>>)>>,165}166#[derive(Default)]167struct Breakpoints(Vec<Rc<Breakpoint>>);168impl Breakpoints {169 fn insert(170 &self,171 stack_depth: usize,172 stack_generation: usize,173 loc: &ExprLocation,174 result: Result<Val>,175 ) -> Result<Val> {176 if self.0.is_empty() {177 return result;178 }179 for item in &self.0 {180 if item.loc.belongs_to(loc) {181 let mut collected = item.collected.borrow_mut();182 let (depth, vals) = collected.entry(stack_generation).or_default();183 if stack_depth > *depth {184 vals.clear();185 }186 vals.push(result.clone());187 }188 }189 result190 }191}192193#[derive(Default)]194pub struct EvaluationStateInternals {195 196 data: RefCell<EvaluationData>,197 198 settings: RefCell<EvaluationSettings>,199}200201202#[derive(Default, Clone)]203pub struct State(Rc<EvaluationStateInternals>);204205impl State {206 207 pub fn add_file(&self, path: Rc<Path>, source_code: IStr) -> Result<LocExpr> {208 let parsed = parse(209 &source_code,210 &ParserSettings {211 file_name: path.clone(),212 },213 )214 .map_err(|error| ImportSyntaxError {215 error: Box::new(error),216 path: path.clone(),217 source_code: source_code.clone(),218 })?;219 self.add_parsed_file(path, source_code, parsed.clone())?;220221 Ok(parsed)222 }223224 pub fn reset_evaluation_state(&self, name: &Path) {225 self.data_mut()226 .files227 .get_mut(name)228 .expect("file not found")229 .evaluated230 .take();231 }232233 234 pub fn add_parsed_file(235 &self,236 name: Rc<Path>,237 source_code: IStr,238 parsed: LocExpr,239 ) -> Result<()> {240 self.data_mut().files.insert(241 name,242 FileData {243 source_code,244 parsed,245 evaluated: None,246 },247 );248249 Ok(())250 }251 pub fn get_source(&self, name: &Path) -> Option<IStr> {252 let ro_map = &self.data().files;253 ro_map.get(name).map(|value| value.source_code.clone())254 }255 pub fn map_source_locations(&self, file: &Path, locs: &[usize]) -> Vec<CodeLocation> {256 offset_to_location(&self.get_source(file).unwrap_or_else(|| "".into()), locs)257 }258 pub fn map_from_source_location(259 &self,260 file: &Path,261 line: usize,262 column: usize,263 ) -> Option<usize> {264 location_to_offset(265 &self.get_source(file).expect("file not found"),266 line,267 column,268 )269 }270 pub fn import_file(&self, from: &Path, path: &Path) -> Result<Val> {271 let file_path = self.resolve_file(from, path)?;272 {273 let data = self.data();274 let files = &data.files;275 if files.contains_key(&file_path as &Path) {276 drop(data);277 return self.evaluate_loaded_file_raw(&file_path);278 }279 }280 let contents = self.load_file_str(&file_path)?;281 self.add_file(file_path.clone(), contents)?;282 self.evaluate_loaded_file_raw(&file_path)283 }284 pub(crate) fn import_file_str(&self, from: &Path, path: &Path) -> Result<IStr> {285 let path = self.resolve_file(from, path)?;286 if !self.data().str_files.contains_key(&path) {287 let file_str = self.load_file_str(&path)?;288 self.data_mut().str_files.insert(path.clone(), file_str);289 }290 Ok(self.data().str_files.get(&path).cloned().unwrap())291 }292 pub(crate) fn import_file_bin(&self, from: &Path, path: &Path) -> Result<Rc<[u8]>> {293 let path = self.resolve_file(from, path)?;294 if !self.data().bin_files.contains_key(&path) {295 let file_bin = self.load_file_bin(&path)?;296 self.data_mut().bin_files.insert(path.clone(), file_bin);297 }298 Ok(self.data().bin_files.get(&path).cloned().unwrap())299 }300301 fn evaluate_loaded_file_raw(&self, name: &Path) -> Result<Val> {302 let expr: LocExpr = {303 let ro_map = &self.data().files;304 let value = ro_map305 .get(name)306 .unwrap_or_else(|| panic!("file not added: {:?}", name));307 if let Some(ref evaluated) = value.evaluated {308 return Ok(evaluated.clone());309 }310 value.parsed.clone()311 };312 let value = evaluate(self.clone(), self.create_default_context(), &expr)?;313 {314 self.data_mut()315 .files316 .get_mut(name)317 .unwrap()318 .evaluated319 .replace(value.clone());320 }321 Ok(value)322 }323324 325 pub fn with_stdlib(&self) -> &Self {326 use jrsonnet_stdlib::STDLIB_STR;327 let std_path: Rc<Path> = PathBuf::from("std.jsonnet").into();328329 self.add_parsed_file(330 std_path.clone(),331 STDLIB_STR.to_owned().into(),332 builtin::get_parsed_stdlib(),333 )334 .expect("stdlib is correct");335 let val = self336 .evaluate_loaded_file_raw(&std_path)337 .expect("stdlib is correct");338 self.settings_mut().globals.insert("std".into(), val);339 self340 }341342 343 pub fn create_default_context(&self) -> Context {344 let globals = &self.settings().globals;345 let mut new_bindings = GcHashMap::with_capacity(globals.len());346 for (name, value) in globals.iter() {347 new_bindings.insert(name.clone(), LazyVal::new_resolved(value.clone()));348 }349 Context::new().extend_bound(new_bindings)350 }351352 353 pub fn push<T>(354 &self,355 e: CallLocation,356 frame_desc: impl FnOnce() -> String,357 f: impl FnOnce() -> Result<T>,358 ) -> Result<T> {359 {360 let mut data = self.data_mut();361 let stack_depth = &mut data.stack_depth;362 if *stack_depth > self.max_stack() {363 364 drop(data);365 throw!(StackOverflow);366 }367 *stack_depth += 1;368 }369 let result = f();370 {371 let mut data = self.data_mut();372 data.stack_depth -= 1;373 data.stack_generation += 1;374 }375 if let Err(mut err) = result {376 err.trace_mut().0.push(StackTraceElement {377 location: e.0.cloned(),378 desc: frame_desc(),379 });380 return Err(err);381 }382 result383 }384385 386 pub fn push_val(387 &self,388 e: &ExprLocation,389 frame_desc: impl FnOnce() -> String,390 f: impl FnOnce() -> Result<Val>,391 ) -> Result<Val> {392 {393 let mut data = self.data_mut();394 let stack_depth = &mut data.stack_depth;395 if *stack_depth > self.max_stack() {396 397 drop(data);398 throw!(StackOverflow);399 }400 *stack_depth += 1;401 }402 let mut result = f();403 {404 let mut data = self.data_mut();405 data.stack_depth -= 1;406 data.stack_generation += 1;407 result = data408 .breakpoints409 .insert(data.stack_depth, data.stack_generation, e, result);410 }411 if let Err(mut err) = result {412 err.trace_mut().0.push(StackTraceElement {413 location: Some(e.clone()),414 desc: frame_desc(),415 });416 return Err(err);417 }418 result419 }420 421 pub fn push_description<T>(422 &self,423 frame_desc: impl FnOnce() -> String,424 f: impl FnOnce() -> Result<T>,425 ) -> Result<T> {426 {427 let mut data = self.data_mut();428 let stack_depth = &mut data.stack_depth;429 if *stack_depth > self.max_stack() {430 431 drop(data);432 throw!(StackOverflow);433 }434 *stack_depth += 1;435 }436 let result = f();437 {438 let mut data = self.data_mut();439 data.stack_depth -= 1;440 data.stack_generation += 1;441 }442 if let Err(mut err) = result {443 err.trace_mut().0.push(StackTraceElement {444 location: None,445 desc: frame_desc(),446 });447 return Err(err);448 }449 result450 }451452 453 454 pub fn stringify_err(&self, e: &LocError) -> String {455 let mut out = String::new();456 self.settings()457 .trace_format458 .write_trace(&mut out, self, e)459 .unwrap();460 out461 }462463 pub fn manifest(&self, val: Val) -> Result<IStr> {464 self.push_description(465 || "manifestification".to_string(),466 || val.manifest(self.clone(), &self.manifest_format()),467 )468 }469 pub fn manifest_multi(&self, val: Val) -> Result<Vec<(IStr, IStr)>> {470 val.manifest_multi(self.clone(), &self.manifest_format())471 }472 pub fn manifest_stream(&self, val: Val) -> Result<Vec<IStr>> {473 val.manifest_stream(self.clone(), &self.manifest_format())474 }475476 477 pub fn with_tla(&self, val: Val) -> Result<Val> {478 Ok(match val {479 Val::Func(func) => self.push_description(480 || "during TLA call".to_owned(),481 || {482 func.evaluate(483 self.clone(),484 self.create_default_context(),485 CallLocation::native(),486 &self.settings().tla_vars,487 true,488 )489 },490 )?,491 v => v,492 })493 }494}495496497impl State {498 fn data(&self) -> Ref<EvaluationData> {499 self.0.data.borrow()500 }501 fn data_mut(&self) -> RefMut<EvaluationData> {502 self.0.data.borrow_mut()503 }504 pub fn settings(&self) -> Ref<EvaluationSettings> {505 self.0.settings.borrow()506 }507 pub fn settings_mut(&self) -> RefMut<EvaluationSettings> {508 self.0.settings.borrow_mut()509 }510}511512513impl State {514 pub fn evaluate_file_raw(&self, name: &Path) -> Result<Val> {515 self.import_file(&std::env::current_dir().expect("cwd"), name)516 }517 pub fn evaluate_file_raw_nocwd(&self, name: &Path) -> Result<Val> {518 self.import_file(&PathBuf::from("."), name)519 }520 521 pub fn evaluate_snippet_raw(&self, source: Rc<Path>, code: IStr) -> Result<Val> {522 let parsed = parse(523 &code,524 &ParserSettings {525 file_name: source.clone(),526 },527 )528 .map_err(|e| ImportSyntaxError {529 path: source.clone(),530 source_code: code.clone(),531 error: Box::new(e),532 })?;533 self.add_parsed_file(source, code, parsed.clone())?;534 self.evaluate_expr_raw(parsed)535 }536 537 pub fn evaluate_expr_raw(&self, code: LocExpr) -> Result<Val> {538 evaluate(self.clone(), self.create_default_context(), &code)539 }540}541542543impl State {544 pub fn add_ext_var(&self, name: IStr, value: Val) {545 self.settings_mut().ext_vars.insert(name, value);546 }547 pub fn add_ext_str(&self, name: IStr, value: IStr) {548 self.add_ext_var(name, Val::Str(value));549 }550 pub fn add_ext_code(&self, name: IStr, code: IStr) -> Result<()> {551 let value =552 self.evaluate_snippet_raw(PathBuf::from(format!("ext_code {}", name)).into(), code)?;553 self.add_ext_var(name, value);554 Ok(())555 }556557 pub fn add_tla(&self, name: IStr, value: Val) {558 self.settings_mut()559 .tla_vars560 .insert(name, TlaArg::Val(value));561 }562 pub fn add_tla_str(&self, name: IStr, value: IStr) {563 self.settings_mut()564 .tla_vars565 .insert(name, TlaArg::String(value));566 }567 pub fn add_tla_code(&self, name: IStr, code: IStr) -> Result<()> {568 let parsed = self.add_file(PathBuf::from(format!("tla_code {}", name)).into(), code)?;569 self.settings_mut()570 .tla_vars571 .insert(name, TlaArg::Code(parsed));572 Ok(())573 }574575 pub fn resolve_file(&self, from: &Path, path: &Path) -> Result<Rc<Path>> {576 self.settings().import_resolver.resolve_file(from, path)577 }578 pub fn load_file_str(&self, path: &Path) -> Result<IStr> {579 self.settings().import_resolver.load_file_str(path)580 }581 pub fn load_file_bin(&self, path: &Path) -> Result<Rc<[u8]>> {582 self.settings().import_resolver.load_file_bin(path)583 }584585 pub fn import_resolver(&self) -> Ref<dyn ImportResolver> {586 Ref::map(self.settings(), |s| &*s.import_resolver)587 }588 pub fn set_import_resolver(&self, resolver: Box<dyn ImportResolver>) {589 self.settings_mut().import_resolver = resolver;590 }591592 pub fn add_native(&self, name: IStr, cb: Cc<TraceBox<dyn Builtin>>) {593 self.settings_mut().ext_natives.insert(name, cb);594 }595596 pub fn manifest_format(&self) -> ManifestFormat {597 self.settings().manifest_format.clone()598 }599 pub fn set_manifest_format(&self, format: ManifestFormat) {600 self.settings_mut().manifest_format = format;601 }602603 pub fn trace_format(&self) -> Ref<dyn TraceFormat> {604 Ref::map(self.settings(), |s| &*s.trace_format)605 }606 pub fn set_trace_format(&self, format: Box<dyn TraceFormat>) {607 self.settings_mut().trace_format = format;608 }609610 pub fn max_trace(&self) -> usize {611 self.settings().max_trace612 }613 pub fn set_max_trace(&self, trace: usize) {614 self.settings_mut().max_trace = trace;615 }616617 pub fn max_stack(&self) -> usize {618 self.settings().max_stack619 }620 pub fn set_max_stack(&self, trace: usize) {621 self.settings_mut().max_stack = trace;622 }623}624625pub fn cc_ptr_eq<T>(a: &Cc<T>, b: &Cc<T>) -> bool {626 let a = a as &T;627 let b = b as &T;628 std::ptr::eq(a, b)629}630631fn weak_raw<T>(a: Weak<T>) -> *const () {632 unsafe { std::mem::transmute(a) }633}634fn weak_ptr_eq<T>(a: Weak<T>, b: Weak<T>) -> bool {635 std::ptr::eq(weak_raw(a), weak_raw(b))636}637638#[test]639fn weak_unsafe() {640 let a = Cc::new(1);641 let b = Cc::new(2);642643 let aw1 = a.clone().downgrade();644 let aw2 = a.clone().downgrade();645 let aw3 = a.clone().downgrade();646647 let bw = b.clone().downgrade();648649 assert!(weak_ptr_eq(aw1, aw2));650 assert!(!weak_ptr_eq(aw3, bw));651}652653#[cfg(test)]654pub mod tests {655 use std::{656 path::{Path, PathBuf},657 rc::Rc,658 };659660 use gcmodule::{Cc, Trace};661 use jrsonnet_parser::*;662663 use super::Val;664 use crate::{665 error::Error::*,666 function::{BuiltinParam, CallLocation},667 gc::TraceBox,668 native::NativeCallbackHandler,669 val::primitive_equals,670 State,671 };672673 #[test]674 #[should_panic]675 fn eval_state_stacktrace() {676 let state = State::default();677 state678 .push(679 CallLocation::new(&ExprLocation(PathBuf::from("test1.jsonnet").into(), 10, 20)),680 || "outer".to_owned(),681 || {682 state.push(683 CallLocation::new(&ExprLocation(684 PathBuf::from("test2.jsonnet").into(),685 30,686 40,687 )),688 || "inner".to_owned(),689 || Err(RuntimeError("".into()).into()),690 )?;691 Ok(Val::Null)692 },693 )694 .unwrap();695 }696697 #[test]698 fn eval_state_standard() {699 let state = State::default();700 state.with_stdlib();701 assert!(primitive_equals(702 &state703 .evaluate_snippet_raw(704 PathBuf::from("raw.jsonnet").into(),705 r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#.into()706 )707 .unwrap(),708 &Val::Bool(true),709 )710 .unwrap());711 }712713 macro_rules! eval {714 ($str: expr) => {{715 let evaluator = State::default();716 evaluator.with_stdlib();717 evaluator718 .evaluate_snippet_raw(PathBuf::from("raw.jsonnet").into(), $str.into())719 .unwrap()720 }};721 }722 macro_rules! eval_json {723 ($str: expr) => {{724 let evaluator = State::default();725 evaluator.with_stdlib();726 evaluator727 .evaluate_snippet_raw(PathBuf::from("raw.jsonnet").into(), $str.into())728 .unwrap()729 .to_json(0)730 .unwrap()731 .replace("\n", "")732 }};733 }734735 736 macro_rules! assert_eval {737 ($str: expr) => {738 assert!(primitive_equals(&eval!($str), &Val::Bool(true)).unwrap())739 };740 }741742 743 macro_rules! assert_eval_neg {744 ($str: expr) => {745 assert!(primitive_equals(&eval!($str), &Val::Bool(false)).unwrap())746 };747 }748 macro_rules! assert_json {749 ($str: expr, $out: expr) => {750 assert_eq!(eval_json!($str), $out.replace("\t", ""))751 };752 }753754 755 #[test]756 fn equality_operator() {757 assert_eval!("2 == 2");758 assert_eval_neg!("2 != 2");759 assert_eval!("2 != 3");760 assert_eval_neg!("2 == 3");761 assert_eval!("'Hello' == 'Hello'");762 assert_eval_neg!("'Hello' != 'Hello'");763 assert_eval!("'Hello' != 'World'");764 assert_eval_neg!("'Hello' == 'World'");765 }766767 #[test]768 fn math_evaluation() {769 assert_eval!("2 + 2 * 2 == 6");770 assert_eval!("3 + (2 + 2 * 2) == 9");771 }772773 #[test]774 fn string_concat() {775 assert_eval!("'Hello' + 'World' == 'HelloWorld'");776 assert_eval!("'Hello' * 3 == 'HelloHelloHello'");777 assert_eval!("'Hello' + 'World' * 3 == 'HelloWorldWorldWorld'");778 }779780 #[test]781 fn faster_join() {782 assert_eval!("std.join([0,0], [[1,2],[3,4],[5,6]]) == [1,2,0,0,3,4,0,0,5,6]");783 assert_eval!("std.join(',', ['1','2','3','4']) == '1,2,3,4'");784 }785786 #[test]787 fn function_contexts() {788 assert_eval!(789 r#"790 local k = {791 t(name = self.h): [self.h, name],792 h: 3,793 };794 local f = {795 t: k.t(),796 h: 4,797 };798 f.t[0] == f.t[1]799 "#800 );801 }802803 #[test]804 fn local() {805 assert_eval!("local a = 2; local b = 3; a + b == 5");806 assert_eval!("local a = 1, b = a + 1; a + b == 3");807 assert_eval!("local a = 1; local a = 2; a == 2");808 }809810 #[test]811 fn object_lazyness() {812 assert_json!("local a = {a:error 'test'}; {}", r#"{}"#);813 }814815 #[test]816 fn object_inheritance() {817 assert_json!("{a: self.b} + {b:3}", r#"{"a": 3,"b": 3}"#);818 }819820 #[test]821 fn object_assertion_success() {822 eval!("{assert \"a\" in self} + {a:2}");823 }824825 #[test]826 fn object_assertion_error() {827 eval!("{assert \"a\" in self}");828 }829830 #[test]831 fn lazy_args() {832 eval!("local test(a) = 2; test(error '3')");833 }834835 #[test]836 #[should_panic]837 fn tailstrict_args() {838 eval!("local test(a) = 2; test(error '3') tailstrict");839 }840841 #[test]842 #[should_panic]843 fn no_binding_error() {844 eval!("a");845 }846847 #[test]848 fn test_object() {849 assert_json!("{a:2}", r#"{"a": 2}"#);850 assert_json!("{a:2+2}", r#"{"a": 4}"#);851 assert_json!("{a:2}+{b:2}", r#"{"a": 2,"b": 2}"#);852 assert_json!("{b:3}+{b:2}", r#"{"b": 2}"#);853 assert_json!("{b:3}+{b+:2}", r#"{"b": 5}"#);854 assert_json!("local test='a'; {[test]:2}", r#"{"a": 2}"#);855 assert_json!(856 r#"857 {858 name: "Alice",859 welcome: "Hello " + self.name + "!",860 }861 "#,862 r#"{"name": "Alice","welcome": "Hello Alice!"}"#863 );864 assert_json!(865 r#"866 {867 name: "Alice",868 welcome: "Hello " + self.name + "!",869 } + {870 name: "Bob"871 }872 "#,873 r#"{"name": "Bob","welcome": "Hello Bob!"}"#874 );875 }876877 #[test]878 fn functions() {879 assert_json!(r#"local a = function(b, c = 2) b + c; a(2)"#, "4");880 assert_json!(881 r#"local a = function(b, c = "Dear") b + c + d, d = "World"; a("Hello")"#,882 r#""HelloDearWorld""#883 );884 }885886 #[test]887 fn local_methods() {888 assert_json!(r#"local a(b, c = 2) = b + c; a(2)"#, "4");889 assert_json!(890 r#"local a(b, c = "Dear") = b + c + d, d = "World"; a("Hello")"#,891 r#""HelloDearWorld""#892 );893 }894895 #[test]896 fn object_locals() {897 assert_json!(r#"{local a = 3, b: a}"#, r#"{"b": 3}"#);898 assert_json!(r#"{local a = 3, local c = a, b: c}"#, r#"{"b": 3}"#);899 assert_json!(900 r#"{local a = function (b) {[b]:4}, test: a("test")}"#,901 r#"{"test": {"test": 4}}"#902 );903 }904905 #[test]906 fn object_comp() {907 assert_json!(908 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}"#,909 "{\"h1_2\": \"0a\",\"h1_3\": \"0a\",\"h1_4\": \"0a\",\"h2_3\": \"a1\",\"h2_4\": \"a1\",\"h3_2\": \"0a\",\"h3_4\": \"a1\"}"910 )911 }912913 #[test]914 fn direct_self() {915 println!(916 "{:#?}",917 eval!(918 r#"919 {920 local me = self,921 a: 3,922 b(): me.a,923 }924 "#925 )926 );927 }928929 #[test]930 fn indirect_self() {931 932 933 eval!(934 r#"{935 local me = self,936 a: 3,937 b: me.a,938 }.b"#939 );940 }941942 943 #[test]944 fn std_assert_ok() {945 eval!("std.assertEqual(4.5 << 2, 16)");946 }947948 #[test]949 #[should_panic]950 fn std_assert_failure() {951 eval!("std.assertEqual(4.5 << 2, 15)");952 }953954 #[test]955 fn string_is_string() {956 assert!(primitive_equals(957 &eval!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),958 &Val::Bool(false),959 )960 .unwrap());961 }962963 #[test]964 fn base64_works() {965 assert_json!(r#"std.base64("test")"#, r#""dGVzdA==""#);966 }967968 #[test]969 fn utf8_chars() {970 assert_json!(971 r#"local c="😎";{c:std.codepoint(c),l:std.length(c)}"#,972 r#"{"c": 128526,"l": 1}"#973 )974 }975976 #[test]977 fn json() {978 assert_json!(979 r#"std.manifestJsonEx({a:3, b:4, c:6},"")"#,980 r#""{\n\"a\": 3,\n\"b\": 4,\n\"c\": 6\n}""#981 );982 }983984 #[test]985 fn json_minified() {986 assert_json!(987 r#"std.manifestJsonMinified({a:3, b:4, c:6})"#,988 r#""{\"a\":3,\"b\":4,\"c\":6}""#989 );990 }991992 #[test]993 fn parse_json() {994 assert_json!(995 r#"std.parseJson('{"a": -1,"b": 1,"c": 3.141,"d": []}')"#,996 r#"{"a": -1,"b": 1,"c": 3.141,"d": []}"#997 );998 }9991000 #[test]1001 fn test() {1002 assert_json!(1003 r#"[[a, b] for a in [1,2,3] for b in [4,5,6]]"#,1004 "[[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]"1005 );1006 }10071008 #[test]1009 fn sjsonnet() {1010 eval!(1011 r#"1012 local x0 = {k: 1};1013 local x1 = {k: x0.k + x0.k};1014 local x2 = {k: x1.k + x1.k};1015 local x3 = {k: x2.k + x2.k};1016 local x4 = {k: x3.k + x3.k};1017 local x5 = {k: x4.k + x4.k};1018 local x6 = {k: x5.k + x5.k};1019 local x7 = {k: x6.k + x6.k};1020 local x8 = {k: x7.k + x7.k};1021 local x9 = {k: x8.k + x8.k};1022 local x10 = {k: x9.k + x9.k};1023 local x11 = {k: x10.k + x10.k};1024 local x12 = {k: x11.k + x11.k};1025 local x13 = {k: x12.k + x12.k};1026 local x14 = {k: x13.k + x13.k};1027 local x15 = {k: x14.k + x14.k};1028 local x16 = {k: x15.k + x15.k};1029 local x17 = {k: x16.k + x16.k};1030 local x18 = {k: x17.k + x17.k};1031 local x19 = {k: x18.k + x18.k};1032 local x20 = {k: x19.k + x19.k};1033 local x21 = {k: x20.k + x20.k};1034 x21.k1035 "#1036 );1037 }10381039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 10511052 10531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078 #[test]1079 fn equality() {1080 println!(1081 "{:?}",1082 jrsonnet_parser::parse(1083 "{ x: 1, y: 2 } == { x: 1, y: 2 }",1084 &ParserSettings {1085 file_name: PathBuf::from("equality").into(),1086 }1087 )1088 );1089 assert_eval!("{ x: 1, y: 2 } == { x: 1, y: 2 }")1090 }10911092 #[test]1093 fn native_ext() -> crate::error::Result<()> {1094 use super::native::NativeCallback;1095 let evaluator = State::default();10961097 evaluator.with_stdlib();10981099 #[derive(Trace)]1100 struct NativeAdd;1101 impl NativeCallbackHandler for NativeAdd {1102 fn call(&self, from: Option<Rc<Path>>, args: &[Val]) -> crate::error::Result<Val> {1103 assert_eq!(1104 &from.unwrap() as &Path,1105 &PathBuf::from("native_caller.jsonnet")1106 );1107 match (&args[0], &args[1]) {1108 (Val::Num(a), Val::Num(b)) => Ok(Val::Num(a + b)),1109 (_, _) => unreachable!(),1110 }1111 }1112 }1113 evaluator.settings_mut().ext_natives.insert(1114 "native_add".into(),1115 #[allow(deprecated)]1116 Cc::new(TraceBox(Box::new(NativeCallback::new(1117 vec![1118 BuiltinParam {1119 name: "a".into(),1120 has_default: false,1121 },1122 BuiltinParam {1123 name: "b".into(),1124 has_default: false,1125 },1126 ],1127 TraceBox(Box::new(NativeAdd)),1128 )))),1129 );1130 dbg!(evaluator.settings().ext_natives.keys().collect::<Vec<_>>());1131 evaluator.evaluate_snippet_raw(1132 PathBuf::from("native_caller.jsonnet").into(),1133 "std.assertEqual(std.native(\"native_add\")(1, 2), 3)".into(),1134 )?;1135 dbg!(evaluator.settings().ext_natives.keys().collect::<Vec<_>>());1136 Ok(())1137 }11381139 #[test]1140 fn constant_intrinsic() -> crate::error::Result<()> {1141 assert_eval!(1142 "local std2 = std; local std = std2 { primitiveEquals(a, b):: false }; 1 == 1"1143 );1144 Ok(())1145 }11461147 #[test]1148 fn standalone_super() -> crate::error::Result<()> {1149 assert_eval!(1150 r#"1151 local obj = {1152 a: 1,1153 b: 2,1154 c: 3,1155 };1156 local test = obj + {1157 fields: std.objectFields(super),1158 d: 5,1159 };1160 test.fields == ['a', 'b', 'c']1161 "#1162 );1163 Ok(())1164 }11651166 #[test]1167 fn comp_self() -> crate::error::Result<()> {1168 assert_eval!(1169 r#"1170 std.objectFields({1171 a:{1172 [name]: name for name in std.objectFields(self)1173 },1174 b: 2,1175 c: 3,1176 }.a) == ['a', 'b', 'c']1177 "#1178 );11791180 Ok(())1181 }11821183 struct TestImportResolver(Vec<u8>);1184 impl crate::import::ImportResolver for TestImportResolver {1185 fn resolve_file(&self, _: &Path, _: &Path) -> crate::error::Result<Rc<Path>> {1186 Ok(PathBuf::from("/test").into())1187 }11881189 fn load_file_contents(&self, _: &Path) -> crate::error::Result<Vec<u8>> {1190 Ok(self.0.clone())1191 }11921193 unsafe fn as_any(&self) -> &dyn std::any::Any {1194 panic!()1195 }11961197 fn load_file_bin(&self, _resolved: &Path) -> crate::error::Result<Rc<[u8]>> {1198 panic!()1199 }1200 }12011202 #[test]1203 fn issue_23() {1204 let state = State::default();1205 state.set_import_resolver(Box::new(TestImportResolver(r#"import "/test""#.into())));1206 let _ = state.evaluate_file_raw(&PathBuf::from("/test"));1207 }12081209 #[test]1210 fn issue_40() {1211 let state = State::default();1212 state.with_stdlib();12131214 let error = state1215 .evaluate_snippet_raw(1216 PathBuf::from("issue40.jsonnet").into(),1217 r#"1218 local conf = {1219 n: ""1220 };12211222 local result = conf + {1223 assert std.isNumber(self.n): "is number"1224 };12251226 std.manifestJsonEx(result, "")1227 "#1228 .into(),1229 )1230 .unwrap_err();1231 assert_eq!(error.error().to_string(), "assert failed: is number");1232 }12331234 #[test]1235 fn test_ascii_upper_lower() {1236 assert_eval!(r#"std.assertEqual(std.asciiUpper("aBc😀"), "ABC😀")"#);1237 assert_eval!(r#"std.assertEqual(std.asciiLower("aBc😀"), "abc😀")"#);1238 }12391240 #[test]1241 fn test_member() {1242 assert_eval!(r#"!std.member("", "")"#);1243 assert_eval!(r#"std.member("abc", "a")"#);1244 assert_eval!(r#"!std.member("abc", "d")"#);1245 assert_eval!(r#"!std.member([], "")"#);1246 assert_eval!(r#"std.member(["a", "b", "c"], "a")"#);1247 assert_eval!(r#"!std.member(["a", "b", "c"], "d")"#);1248 }12491250 #[test]1251 fn test_count() {1252 assert_eval!(r#"std.assertEqual(std.count([], ""), 0)"#);1253 assert_eval!(r#"std.assertEqual(std.count(["a", "b", "a"], "d"), 0)"#);1254 assert_eval!(r#"std.assertEqual(std.count(["a", "b", "a"], "a"), 2)"#);1255 }1256}