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()),

136136
137#[test]137#[test]
138fn test() -> Result<()> {138fn test() -> Result<()> {
139	use jrsonnet_parser::*;
140	use crate::val::ValType;139	use crate::val::ValType;
140	use jrsonnet_parser::*;
141	let state = crate::EvaluationState::default();141	let state = crate::EvaluationState::default();
142	let evaluator = state.with_stdlib();142	let evaluator = state.with_stdlib();
143	let ctx = evaluator.create_default_context()?;143	let ctx = evaluator.create_default_context()?;

--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -7,6 +7,7 @@
 
 extern crate test;
 
+mod builtin;
 mod ctx;
 mod dynamic;
 mod error;
@@ -15,8 +16,8 @@
 mod import;
 mod map;
 mod obj;
-mod val;
 pub mod trace;
+mod val;
 
 pub use ctx::*;
 pub use dynamic::*;
@@ -26,9 +27,15 @@
 pub use import::*;
 use jrsonnet_parser::*;
 pub use obj::*;
-use std::{cell::{Ref, RefCell, RefMut}, collections::HashMap, fmt::Debug, path::PathBuf, rc::Rc};
+use std::{
+	cell::{Ref, RefCell, RefMut},
+	collections::HashMap,
+	fmt::Debug,
+	path::PathBuf,
+	rc::Rc,
+};
+use trace::{offset_to_location, CodeLocation};
 pub use val::*;
-use trace::{offset_to_location, CodeLocation};
 
 type BindableFn = dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Result<LazyVal>;
 #[derive(Clone)]
@@ -319,7 +326,7 @@
 				drop(data);
 				return Err(self.error(Error::StackOverflow));
 			} else {
-				*stack_depth+=1;
+				*stack_depth += 1;
 			}
 		}
 		let result = f();
@@ -355,30 +362,28 @@
 #[cfg(test)]
 pub mod tests {
 	use super::Val;
-	use crate::{create_error, EvaluationState, primitive_equals};
+	use crate::{create_error, primitive_equals, EvaluationState};
 	use jrsonnet_parser::*;
 	use std::{path::PathBuf, rc::Rc};
 
 	#[test]
 	fn eval_state_stacktrace() {
 		let state = EvaluationState::default();
-		state.run_in_state(||{
+		state.run_in_state(|| {
 			state
-			.push(
-				&ExprLocation(Rc::new(PathBuf::from("test1.jsonnet")), 10, 20),
-				|| "outer".to_owned(),
-				|| {
-					state.push(
-						&ExprLocation(Rc::new(PathBuf::from("test2.jsonnet")), 30, 40),
-						|| "inner".to_owned(),
-						|| {
-							Err(create_error(crate::error::Error::RuntimeError("".into())))
-						},
-					)?;
-					Ok(())
-				},
-			)
-			.unwrap();
+				.push(
+					&ExprLocation(Rc::new(PathBuf::from("test1.jsonnet")), 10, 20),
+					|| "outer".to_owned(),
+					|| {
+						state.push(
+							&ExprLocation(Rc::new(PathBuf::from("test2.jsonnet")), 30, 40),
+							|| "inner".to_owned(),
+							|| Err(create_error(crate::error::Error::RuntimeError("".into()))),
+						)?;
+						Ok(())
+					},
+				)
+				.unwrap();
 		});
 	}
 
@@ -386,19 +391,23 @@
 	fn eval_state_standard() {
 		let state = EvaluationState::default();
 		state.with_stdlib();
-		assert!(
-			primitive_equals(
-				&state.parse_evaluate_raw(r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#).unwrap(),
-				&Val::Bool(true),
-			).unwrap()
-		);
+		assert!(primitive_equals(
+			&state
+				.parse_evaluate_raw(
+					Rc::new(PathBuf::from("raw.jsonnet")),
+					r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#
+				)
+				.unwrap(),
+			&Val::Bool(true),
+		)
+		.unwrap());
 	}
 
 	macro_rules! eval {
 		($str: expr) => {
 			EvaluationState::default()
 				.with_stdlib()
-				.parse_evaluate_raw($str)
+				.parse_evaluate_raw(Rc::new(PathBuf::from("raw.jsonnet")), $str)
 				.unwrap()
 		};
 	}
@@ -406,15 +415,15 @@
 		($str: expr) => {{
 			let evaluator = EvaluationState::default();
 			evaluator.with_stdlib();
-			evaluator.run_in_state(||{
+			evaluator.run_in_state(|| {
 				evaluator
-					.parse_evaluate_raw($str)
+					.parse_evaluate_raw(Rc::new(PathBuf::from("raw.jsonnet")), $str)
 					.unwrap()
 					.into_json(0)
 					.unwrap()
 					.replace("\n", "")
-			})
-		}}
+				})
+			}};
 	}
 
 	/// Asserts given code returns `true`
@@ -638,12 +647,11 @@
 
 	#[test]
 	fn string_is_string() {
-		assert!(
-			primitive_equals(
-				&eval!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),
-				&Val::Bool(false),
-			).unwrap()
-		);
+		assert!(primitive_equals(
+			&eval!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),
+			&Val::Bool(false),
+		)
+		.unwrap());
 	}
 
 	#[test]
@@ -746,8 +754,14 @@
 	}
 
 	#[test]
-	fn equality(){
-		println!("{:?}", jrsonnet_parser::parse("{ x: 1, y: 2 } == { x: 1, y: 2 }", &ParserSettings::default()));
+	fn equality() {
+		println!(
+			"{:?}",
+			jrsonnet_parser::parse(
+				"{ x: 1, y: 2 } == { x: 1, y: 2 }",
+				&ParserSettings::default()
+			)
+		);
 		assert_eval!("{ x: 1, y: 2 } == { x: 1, y: 2 }")
 	}
 }

--- 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(())