git.delta.rocks / jrsonnet / refs/commits / 433adfa9b8ae

--- a/cmds/jrsonnet/src/main.rs
+++ b/cmds/jrsonnet/src/main.rs
@@ -134,19 +134,30 @@
 
 fn main_real(opts: Opts) {
 	let evaluator = jrsonnet_evaluator::EvaluationState::default();
-	evaluator.set_max_trace(opts.max_trace);
-	evaluator.set_max_stack(opts.max_stack);
-	evaluator.set_import_resolver(Box::new(jrsonnet_evaluator::FileImportResolver {
-		library_paths: opts.jpath.clone(),
-	}));
+	{
+		let mut settings = evaluator.settings_mut();
+		settings.max_stack = opts.max_stack;
+		settings.max_trace = opts.max_trace;
+		settings.import_resolver = Box::new(jrsonnet_evaluator::FileImportResolver {
+			library_paths: opts.jpath.clone(),
+		});
+	}
 	if !opts.no_stdlib {
 		evaluator.with_stdlib();
 	}
 	for ExtStr { name, value } in opts.ext_str.iter().cloned() {
-		evaluator.add_ext_var(name.into(), Val::Str(value.into()));
+		evaluator
+			.settings_mut()
+			.ext_vars
+			.insert(name.into(), Val::Str(value.into()));
 	}
 	for ExtStr { name, value } in opts.ext_code.iter().cloned() {
-		evaluator.add_ext_var(name.into(), evaluator.parse_evaluate_raw(&value).unwrap());
+		evaluator.settings_mut().ext_vars.insert(
+			name.clone().into(),
+			evaluator
+				.parse_evaluate_raw(PathBuf::from(format!("ext_code {}", name)).into(), &value)
+				.unwrap(),
+		);
 	}
 
 	let resolver = PathResolver::Relative(std::env::current_dir().unwrap());
@@ -184,8 +195,11 @@
 							.unwrap(),
 						);
 					}
-					evaluator.add_global("__tmp__tlf__".into(), Val::Func(f));
 					evaluator
+						.settings_mut()
+						.globals
+						.insert("__tmp__tlf__".into(), Val::Func(f));
+					evaluator
 						.evaluate_raw(el!(Expr::Apply(
 							el!(Expr::Var("__tmp__tlf__".into())),
 							ArgsDesc(desc_map.into_iter().map(|(k, v)| Arg(Some(k), v)).collect()),

--- a/crates/jrsonnet-evaluator/src/function.rs
+++ b/crates/jrsonnet-evaluator/src/function.rs
@@ -136,8 +136,8 @@
 
 #[test]
 fn test() -> Result<()> {
+	use crate::val::ValType;
 	use jrsonnet_parser::*;
-	use crate::val::ValType;
 	let state = crate::EvaluationState::default();
 	let evaluator = state.with_stdlib();
 	let ctx = evaluator.create_default_context()?;

77
8extern crate test;8extern crate test;
99
10mod builtin;
10mod ctx;11mod ctx;
11mod dynamic;12mod dynamic;
12mod error;13mod error;
15mod import;16mod import;
16mod map;17mod map;
17mod obj;18mod obj;
18mod val;
19pub mod trace;19pub mod trace;
20mod val;
2021
21pub use ctx::*;22pub use ctx::*;
22pub use dynamic::*;23pub use dynamic::*;
27use jrsonnet_parser::*;28use jrsonnet_parser::*;
28pub use obj::*;29pub use obj::*;
29use std::{cell::{Ref, RefCell, RefMut}, collections::HashMap, fmt::Debug, path::PathBuf, rc::Rc};30use std::{
30pub use val::*;31	cell::{Ref, RefCell, RefMut},
32	collections::HashMap,
33	fmt::Debug,
34	path::PathBuf,
35	rc::Rc,
36};
31use trace::{offset_to_location, CodeLocation};37use trace::{offset_to_location, CodeLocation};
38pub use val::*;
3239
33type BindableFn = dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Result<LazyVal>;40type BindableFn = dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Result<LazyVal>;
34#[derive(Clone)]41#[derive(Clone)]
355#[cfg(test)]362#[cfg(test)]
356pub mod tests {363pub mod tests {
357	use super::Val;364	use super::Val;
358	use crate::{create_error, EvaluationState, primitive_equals};365	use crate::{create_error, primitive_equals, EvaluationState};
359	use jrsonnet_parser::*;366	use jrsonnet_parser::*;
360	use std::{path::PathBuf, rc::Rc};367	use std::{path::PathBuf, rc::Rc};
361368
371					state.push(378						state.push(
372						&ExprLocation(Rc::new(PathBuf::from("test2.jsonnet")), 30, 40),379							&ExprLocation(Rc::new(PathBuf::from("test2.jsonnet")), 30, 40),
373						|| "inner".to_owned(),380							|| "inner".to_owned(),
374						|| {381							|| Err(create_error(crate::error::Error::RuntimeError("".into()))),
375							Err(create_error(crate::error::Error::RuntimeError("".into())))
376						},
377					)?;382						)?;
378					Ok(())383						Ok(())
379				},384					},
390			primitive_equals(
391				&state.parse_evaluate_raw(r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#).unwrap(),395			&state
396				.parse_evaluate_raw(
397					Rc::new(PathBuf::from("raw.jsonnet")),
398					r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#
399				)
400				.unwrap(),
398		($str: expr) => {407		($str: expr) => {
399			EvaluationState::default()408			EvaluationState::default()
400				.with_stdlib()409				.with_stdlib()
401				.parse_evaluate_raw($str)410				.parse_evaluate_raw(Rc::new(PathBuf::from("raw.jsonnet")), $str)
402				.unwrap()411				.unwrap()
403		};412		};
404	}413	}
408			evaluator.with_stdlib();417			evaluator.with_stdlib();
409			evaluator.run_in_state(||{418			evaluator.run_in_state(|| {
410				evaluator419				evaluator
411					.parse_evaluate_raw($str)420					.parse_evaluate_raw(Rc::new(PathBuf::from("raw.jsonnet")), $str)
412					.unwrap()421					.unwrap()
413					.into_json(0)422					.into_json(0)
414					.unwrap()423					.unwrap()
415					.replace("\n", "")424					.replace("\n", "")
416			})425				})
417		}}426			}};
418	}427	}
419428
420	/// Asserts given code returns `true`429	/// Asserts given code returns `true`

--- a/crates/jrsonnet-evaluator/src/val.rs
+++ b/crates/jrsonnet-evaluator/src/val.rs
@@ -358,7 +358,9 @@
 			buf.push_str(cur_padding);
 			buf.push('}');
 		}
-		Val::Func(_) | Val::Intristic(_, _) => create_error_result(Error::RuntimeError("tried to manifest function".into()))?,
+		Val::Func(_) | Val::Intristic(_, _) => {
+			create_error_result(Error::RuntimeError("tried to manifest function".into()))?
+		}
 		Val::Lazy(_) => unreachable!(),
 	};
 	Ok(())