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

134134
135fn main_real(opts: Opts) {135fn main_real(opts: Opts) {
136	let evaluator = jrsonnet_evaluator::EvaluationState::default();136	let evaluator = jrsonnet_evaluator::EvaluationState::default();
137	{
137	evaluator.set_max_trace(opts.max_trace);138		let mut settings = evaluator.settings_mut();
138	evaluator.set_max_stack(opts.max_stack);139		settings.max_stack = opts.max_stack;
140		settings.max_trace = opts.max_trace;
139	evaluator.set_import_resolver(Box::new(jrsonnet_evaluator::FileImportResolver {141		settings.import_resolver = Box::new(jrsonnet_evaluator::FileImportResolver {
140		library_paths: opts.jpath.clone(),142			library_paths: opts.jpath.clone(),
141	}));143		});
144	}
142	if !opts.no_stdlib {145	if !opts.no_stdlib {
143		evaluator.with_stdlib();146		evaluator.with_stdlib();
144	}147	}
145	for ExtStr { name, value } in opts.ext_str.iter().cloned() {148	for ExtStr { name, value } in opts.ext_str.iter().cloned() {
146		evaluator.add_ext_var(name.into(), Val::Str(value.into()));149		evaluator
150			.settings_mut()
151			.ext_vars
152			.insert(name.into(), Val::Str(value.into()));
147	}153	}
148	for ExtStr { name, value } in opts.ext_code.iter().cloned() {154	for ExtStr { name, value } in opts.ext_code.iter().cloned() {
149		evaluator.add_ext_var(name.into(), evaluator.parse_evaluate_raw(&value).unwrap());155		evaluator.settings_mut().ext_vars.insert(
156			name.clone().into(),
157			evaluator
158				.parse_evaluate_raw(PathBuf::from(format!("ext_code {}", name)).into(), &value)
159				.unwrap(),
160		);
150	}161	}
184							.unwrap(),195							.unwrap(),
185						);196						);
186					}197					}
187					evaluator.add_global("__tmp__tlf__".into(), Val::Func(f));198					evaluator
199						.settings_mut()
200						.globals
201						.insert("__tmp__tlf__".into(), Val::Func(f));
188					evaluator202					evaluator
189						.evaluate_raw(el!(Expr::Apply(203						.evaluate_raw(el!(Expr::Apply(
190							el!(Expr::Var("__tmp__tlf__".into())),204							el!(Expr::Var("__tmp__tlf__".into())),

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

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