git.delta.rocks / jrsonnet / refs/commits / afca77d1e35b

2727
28use std::{28use std::{
29	any::Any,29	any::Any,
30	cell::{Ref, RefCell, RefMut},30	cell::{RefCell, RefMut},
31	fmt::{self, Debug},31	fmt::{self, Debug},
32	path::Path,32	path::Path,
33};33};
147	A @ B C D E F G147	A @ B C D E F G
148}148}
149
150/// Dynamically reconfigurable evaluation settings
151#[derive(Trace)]
152pub struct EvaluationSettings {
153	/// Context initializer, which will be used for imports and everything
154	/// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`
155	pub context_initializer: TraceBox<dyn ContextInitializer>,
156	/// Used to resolve file locations/contents
157	pub import_resolver: TraceBox<dyn ImportResolver>,
158}
159impl Default for EvaluationSettings {
160	fn default() -> Self {
161		Self {
162			context_initializer: tb!(()),
163			import_resolver: tb!(DummyImportResolver),
164		}
165	}
166}
167149
168#[derive(Trace)]150#[derive(Trace)]
169struct FileData {151struct FileData {
207	}189	}
208}190}
209191
210#[derive(Default, Trace)]192#[derive(Trace)]
211pub struct EvaluationStateInternals {193pub struct EvaluationStateInternals {
212	/// Internal state194	/// Internal state
213	file_cache: RefCell<GcHashMap<SourcePath, FileData>>,195	file_cache: RefCell<GcHashMap<SourcePath, FileData>>,
214	/// Settings, safe to change at runtime196	/// Context initializer, which will be used for imports and everything
197	/// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`
198	context_initializer: TraceBox<dyn ContextInitializer>,
199	/// Used to resolve file locations/contents
215	settings: RefCell<EvaluationSettings>,200	import_resolver: TraceBox<dyn ImportResolver>,
216}201}
217202
218/// Maintains stack trace and import resolution203/// Maintains stack trace and import resolution
219#[derive(Default, Clone, Trace)]204#[derive(Clone, Trace)]
220pub struct State(Cc<EvaluationStateInternals>);205pub struct State(Cc<EvaluationStateInternals>);
221206
222impl State {207impl State {
228		let file = match file {213		let file = match file {
229			RawEntryMut::Occupied(ref mut d) => d.get_mut(),214			RawEntryMut::Occupied(ref mut d) => d.get_mut(),
230			RawEntryMut::Vacant(v) => {215			RawEntryMut::Vacant(v) => {
231				let data = self.settings().import_resolver.load_file_contents(&path)?;216				let data = self.import_resolver().load_file_contents(&path)?;
232				v.insert(217				v.insert(
233					path.clone(),218					path.clone(),
234					FileData::new_string(219					FileData::new_string(
252		let file = match file {237		let file = match file {
253			RawEntryMut::Occupied(ref mut d) => d.get_mut(),238			RawEntryMut::Occupied(ref mut d) => d.get_mut(),
254			RawEntryMut::Vacant(v) => {239			RawEntryMut::Vacant(v) => {
255				let data = self.settings().import_resolver.load_file_contents(&path)?;240				let data = self.import_resolver().load_file_contents(&path)?;
256				v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))241				v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))
257					.1242					.1
258			}243			}
279		let file = match file {264		let file = match file {
280			RawEntryMut::Occupied(ref mut d) => d.get_mut(),265			RawEntryMut::Occupied(ref mut d) => d.get_mut(),
281			RawEntryMut::Vacant(v) => {266			RawEntryMut::Vacant(v) => {
282				let data = self.settings().import_resolver.load_file_contents(&path)?;267				let data = self.import_resolver().load_file_contents(&path)?;
283				v.insert(268				v.insert(
284					path.clone(),269					path.clone(),
285					FileData::new_string(270					FileData::new_string(
350335
351	/// Creates context with all passed global variables336	/// Creates context with all passed global variables
352	pub fn create_default_context(&self, source: Source) -> Context {337	pub fn create_default_context(&self, source: Source) -> Context {
353		let context_initializer = &self.settings().context_initializer;
354		context_initializer.initialize(self.clone(), source)338		self.context_initializer().initialize(self.clone(), source)
355	}339	}
356340
357	/// Creates context with all passed global variables, calling custom modifier341	/// Creates context with all passed global variables, calling custom modifier
360		source: Source,344		source: Source,
361		context_initializer: impl ContextInitializer,345		context_initializer: impl ContextInitializer,
362	) -> Context {346	) -> Context {
363		let default_initializer = &self.settings().context_initializer;347		let default_initializer = self.context_initializer();
364		let mut builder = ContextBuilder::with_capacity(348		let mut builder = ContextBuilder::with_capacity(
365			self.clone(),349			self.clone(),
366			default_initializer.reserve_vars() + context_initializer.reserve_vars(),350			default_initializer.reserve_vars() + context_initializer.reserve_vars(),
409	fn file_cache(&self) -> RefMut<'_, GcHashMap<SourcePath, FileData>> {393	fn file_cache(&self) -> RefMut<'_, GcHashMap<SourcePath, FileData>> {
410		self.0.file_cache.borrow_mut()394		self.0.file_cache.borrow_mut()
411	}395	}
412	pub fn settings(&self) -> Ref<'_, EvaluationSettings> {
413		self.0.settings.borrow()
414	}
415	pub fn settings_mut(&self) -> RefMut<'_, EvaluationSettings> {
416		self.0.settings.borrow_mut()
417	}
418	pub fn add_global(&self, name: IStr, value: Thunk<Val>) {
419		#[derive(Trace)]
420		struct GlobalsCtx {
421			globals: RefCell<GcHashMap<IStr, Thunk<Val>>>,
422			inner: TraceBox<dyn ContextInitializer>,
423		}
424		impl ContextInitializer for GlobalsCtx {
425			fn reserve_vars(&self) -> usize {
426				self.inner.reserve_vars() + self.globals.borrow().len()
427			}
428			fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {
429				self.inner.populate(for_file, builder);
430				for (name, val) in self.globals.borrow().iter() {
431					builder.bind(name.clone(), val.clone());
432				}
433			}
434
435			fn as_any(&self) -> &dyn Any {
436				self
437			}
438		}
439		let mut settings = self.settings_mut();
440		let initializer = &mut settings.context_initializer;
441		if let Some(global) = initializer.as_any().downcast_ref::<GlobalsCtx>() {
442			global.globals.borrow_mut().insert(name, value);
443		} else {
444			let inner = std::mem::replace(&mut settings.context_initializer, tb!(()));
445			settings.context_initializer = tb!(GlobalsCtx {
446				globals: {
447					let mut out = GcHashMap::with_capacity(1);
448					out.insert(name, value);
449					RefCell::new(out)
450				},
451				inner
452			});
453		}
454	}
455}396}
456397
457#[derive(Trace)]398#[derive(Trace)]
523	pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {464	pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {
524		self.import_resolver().resolve(path.as_ref())465		self.import_resolver().resolve(path.as_ref())
525	}466	}
526	pub fn import_resolver(&self) -> Ref<'_, dyn ImportResolver> {467	pub fn import_resolver(&self) -> &dyn ImportResolver {
527		Ref::map(self.settings(), |s| &*s.import_resolver)468		&*self.0.import_resolver
528	}469	}
529	pub fn set_import_resolver(&self, resolver: impl ImportResolver) {
530		self.settings_mut().import_resolver = tb!(resolver);
531	}
532	pub fn context_initializer(&self) -> Ref<'_, dyn ContextInitializer> {470	pub fn context_initializer(&self) -> &dyn ContextInitializer {
533		Ref::map(self.settings(), |s| &*s.context_initializer)471		&*self.0.context_initializer
534	}472	}
535	pub fn set_context_initializer(&self, initializer: impl ContextInitializer) {
536		self.settings_mut().context_initializer = tb!(initializer);
537	}
538}473}
474
475impl State {
476	pub fn builder() -> StateBuilder {
477		StateBuilder::default()
478	}
479}
480
481impl Default for State {
482	fn default() -> Self {
483		Self::builder().build()
484	}
485}
486
487#[derive(Default)]
488pub struct StateBuilder {
489	import_resolver: Option<TraceBox<dyn ImportResolver>>,
490	context_initializer: Option<TraceBox<dyn ContextInitializer>>,
491}
492impl StateBuilder {
493	pub fn import_resolver(&mut self, import_resolver: impl ImportResolver) -> &mut Self {
494		let _ = self.import_resolver.insert(tb!(import_resolver));
495		self
496	}
497	pub fn context_initializer(
498		&mut self,
499		context_initializer: impl ContextInitializer,
500	) -> &mut Self {
501		let _ = self.context_initializer.insert(tb!(context_initializer));
502		self
503	}
504	pub fn build(mut self) -> State {
505		State(Cc::new(EvaluationStateInternals {
506			file_cache: RefCell::new(GcHashMap::new()),
507			context_initializer: self.context_initializer.take().unwrap_or_else(|| tb!(())),
508			import_resolver: self
509				.import_resolver
510				.take()
511				.unwrap_or_else(|| tb!(DummyImportResolver)),
512		}))
513	}
514}
539515

--- a/tests/tests/as_native.rs
+++ b/tests/tests/as_native.rs
@@ -1,14 +1,16 @@
-use jrsonnet_evaluator::{Result, State};
-use jrsonnet_stdlib::StateExt;
+use jrsonnet_evaluator::{trace::PathResolver, FileImportResolver, Result, State};
+use jrsonnet_stdlib::ContextInitializer;
 
 mod common;
 
 #[test]
 fn as_native() -> Result<()> {
-	let s = State::default();
-	s.with_stdlib();
+	let mut s = State::builder();
+	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()))
+		.import_resolver(FileImportResolver::default());
+	let s = s.build();
 
-	let val = s.evaluate_snippet("snip".to_owned(), r#"function(a, b) a + b"#)?;
+	let val = s.evaluate_snippet("snip".to_owned(), r"function(a, b) a + b")?;
 	let func = val.as_func().expect("this is function");
 
 	let native = func.into_native::<((u32, u32), u32)>();

--- a/tests/tests/builtin.rs
+++ b/tests/tests/builtin.rs
@@ -2,10 +2,13 @@
 
 use jrsonnet_evaluator::{
 	function::{builtin, builtin::Builtin, CallLocation, FuncVal},
+	parser::Source,
+	trace::PathResolver,
 	typed::Typed,
-	ContextBuilder, Result, State, Thunk, Val,
+	ContextBuilder, ContextInitializer, FileImportResolver, Result, State, Thunk, Val,
 };
-use jrsonnet_stdlib::StateExt;
+use jrsonnet_gcmodule::Trace;
+use jrsonnet_stdlib::ContextInitializer as StdContextInitializer;
 
 #[builtin]
 fn a() -> Result<u32> {
@@ -29,15 +32,30 @@
 fn native_add(a: u32, b: u32) -> Result<u32> {
 	Ok(a + b)
 }
+#[derive(Trace)]
+struct NativeAddContextInitializer;
+impl ContextInitializer for NativeAddContextInitializer {
+	fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {
+		builder.bind(
+			"nativeAdd",
+			Thunk::evaluated(Val::function(native_add::INST)),
+		);
+	}
 
+	fn as_any(&self) -> &dyn std::any::Any {
+		self
+	}
+}
+
 #[test]
 fn call_from_code() -> Result<()> {
-	let s = State::default();
-	s.with_stdlib();
-	s.add_global(
-		"nativeAdd".into(),
-		Thunk::evaluated(Val::function(native_add::INST)),
-	);
+	let mut s = State::builder();
+	s.context_initializer((
+		StdContextInitializer::new(PathResolver::new_cwd_fallback()),
+		NativeAddContextInitializer,
+	))
+	.import_resolver(FileImportResolver::default());
+	let s = s.build();
 
 	let v = s.evaluate_snippet(
 		"snip".to_owned(),
@@ -62,15 +80,27 @@
 fn curry_add(a: u32) -> Result<FuncVal> {
 	Ok(FuncVal::builtin(curried_add { a }))
 }
+#[derive(Trace)]
+struct CurryAddContextInitializer;
+impl ContextInitializer for CurryAddContextInitializer {
+	fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {
+		builder.bind("curryAdd", Thunk::evaluated(Val::function(curry_add::INST)));
+	}
 
+	fn as_any(&self) -> &dyn std::any::Any {
+		self
+	}
+}
+
 #[test]
 fn nonstatic_builtin() -> Result<()> {
-	let s = State::default();
-	s.with_stdlib();
-	s.add_global(
-		"curryAdd".into(),
-		Thunk::evaluated(Val::function(curry_add::INST)),
-	);
+	let mut s = State::builder();
+	s.context_initializer((
+		StdContextInitializer::new(PathResolver::new_cwd_fallback()),
+		CurryAddContextInitializer,
+	))
+	.import_resolver(FileImportResolver::default());
+	let s = s.build();
 
 	let v = s.evaluate_snippet(
 		"snip".to_owned(),

--- a/tests/tests/common.rs
+++ b/tests/tests/common.rs
@@ -1,8 +1,10 @@
 use jrsonnet_evaluator::{
 	bail,
 	function::{builtin, FuncVal},
-	ObjValueBuilder, Result, State, Thunk, Val,
+	parser::Source,
+	ContextBuilder, ContextInitializer as ContextInitializerT, ObjValueBuilder, Result, Thunk, Val,
 };
+use jrsonnet_gcmodule::Trace;
 
 #[macro_export]
 macro_rules! ensure_eq {
@@ -74,11 +76,18 @@
 	}
 }
 
-#[allow(dead_code)]
-pub fn with_test(s: &State) {
-	let mut bobj = ObjValueBuilder::new();
-	bobj.method("assertThrow", assert_throw::INST);
-	bobj.method("paramNames", param_names::INST);
+#[derive(Trace)]
+pub struct ContextInitializer;
+impl ContextInitializerT for ContextInitializer {
+	fn populate(&self, _for_file: Source, builder: &mut ContextBuilder) {
+		let mut bobj = ObjValueBuilder::new();
+		bobj.method("assertThrow", assert_throw::INST);
+		bobj.method("paramNames", param_names::INST);
 
-	s.add_global("test".into(), Thunk::evaluated(Val::Obj(bobj.build())))
+		builder.bind("test", Thunk::evaluated(Val::Obj(bobj.build())));
+	}
+
+	fn as_any(&self) -> &dyn std::any::Any {
+		self
+	}
 }

--- a/tests/tests/golden.rs
+++ b/tests/tests/golden.rs
@@ -8,14 +8,19 @@
 	trace::{CompactFormat, PathResolver, TraceFormat},
 	FileImportResolver, State,
 };
-use jrsonnet_stdlib::StateExt;
+use jrsonnet_stdlib::ContextInitializer;
 mod common;
+use common::ContextInitializer as TestContextInitializer;
 
 fn run(file: &Path) -> String {
-	let s = State::default();
-	s.with_stdlib();
-	common::with_test(&s);
-	s.set_import_resolver(FileImportResolver::default());
+	let mut s = State::builder();
+	s.context_initializer((
+		ContextInitializer::new(PathResolver::new_cwd_fallback()),
+		TestContextInitializer,
+	))
+	.import_resolver(FileImportResolver::default());
+	let s = s.build();
+
 	let trace_format = CompactFormat {
 		resolver: PathResolver::FileName,
 		max_trace: 20,

--- a/tests/tests/sanity.rs
+++ b/tests/tests/sanity.rs
@@ -1,16 +1,18 @@
 use jrsonnet_evaluator::{
 	bail,
-	trace::{CompactFormat, TraceFormat},
-	Result, State, Val,
+	trace::{CompactFormat, PathResolver, TraceFormat},
+	FileImportResolver, Result, State, Val,
 };
-use jrsonnet_stdlib::StateExt;
+use jrsonnet_stdlib::ContextInitializer;
 
 mod common;
 
 #[test]
 fn assert_positive() -> Result<()> {
-	let s = State::default();
-	s.with_stdlib();
+	let mut s = State::builder();
+	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()))
+		.import_resolver(FileImportResolver::default());
+	let s = s.build();
 
 	let v = s.evaluate_snippet("snip".to_owned(), "assert 1 == 1: 'fail'; null")?;
 	ensure_val_eq!(v, Val::Null);
@@ -22,8 +24,11 @@
 
 #[test]
 fn assert_negative() -> Result<()> {
-	let s = State::default();
-	s.with_stdlib();
+	let mut s = State::builder();
+	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()))
+		.import_resolver(FileImportResolver::default());
+	let s = s.build();
+
 	let trace_format = CompactFormat::default();
 
 	{
@@ -38,7 +43,7 @@
 			bail!("assertion should fail")
 		};
 		let e = trace_format.format(&e).unwrap();
-		ensure!(e.starts_with("runtime error: Assertion failed. 1 != 2"))
+		ensure!(e.starts_with("runtime error: assertion failed: A != B\nA: 1\nB: 2\n"));
 	}
 
 	Ok(())

--- a/tests/tests/std_native.rs
+++ b/tests/tests/std_native.rs
@@ -8,10 +8,11 @@
 
 #[test]
 fn std_native() {
-	let state = State::default();
-	let std = ContextInitializer::new(state.clone(), PathResolver::Absolute);
+	let mut state = State::builder();
+	let std = ContextInitializer::new(PathResolver::Absolute);
 	std.add_native("example", example_native::INST);
-	state.set_context_initializer(std);
+	state.context_initializer(std);
+	let state = state.build();
 
 	assert!(state
 		.evaluate_snippet("test", "std.native('example')(1, 3) == 4")

--- a/tests/tests/suite.rs
+++ b/tests/tests/suite.rs
@@ -4,18 +4,23 @@
 };
 
 use jrsonnet_evaluator::{
-	trace::{CompactFormat, TraceFormat},
+	trace::{CompactFormat, PathResolver, TraceFormat},
 	FileImportResolver, State, Val,
 };
-use jrsonnet_stdlib::StateExt;
+use jrsonnet_stdlib::ContextInitializer;
 
 mod common;
+use common::ContextInitializer as TestContextInitializer;
 
 fn run(file: &Path) {
-	let s = State::default();
-	s.with_stdlib();
-	common::with_test(&s);
-	s.set_import_resolver(FileImportResolver::default());
+	let mut s = State::builder();
+	s.context_initializer((
+		ContextInitializer::new(PathResolver::new_cwd_fallback()),
+		TestContextInitializer,
+	))
+	.import_resolver(FileImportResolver::default());
+	let s = s.build();
+
 	let trace_format = CompactFormat::default();
 
 	match s.import(file) {

--- a/tests/tests/typed_obj.rs
+++ b/tests/tests/typed_obj.rs
@@ -2,8 +2,8 @@
 
 use std::fmt::Debug;
 
-use jrsonnet_evaluator::{typed::Typed, Result, State};
-use jrsonnet_stdlib::StateExt;
+use jrsonnet_evaluator::{trace::PathResolver, typed::Typed, Result, State};
+use jrsonnet_stdlib::ContextInitializer;
 
 #[derive(Clone, Typed, PartialEq, Debug)]
 struct A {
@@ -23,8 +23,10 @@
 
 #[test]
 fn simple_object() -> Result<()> {
-	let s = State::default();
-	s.with_stdlib();
+	let mut s = State::builder();
+	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
+	let s = s.build();
+
 	let a = A::from_untyped(s.evaluate_snippet("snip".to_owned(), "{a: 1, b: 2}")?)?;
 	ensure_eq!(a, A { a: 1, b: 2 });
 	test_roundtrip(a)?;
@@ -40,8 +42,10 @@
 
 #[test]
 fn renamed_field() -> Result<()> {
-	let s = State::default();
-	s.with_stdlib();
+	let mut s = State::builder();
+	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
+	let s = s.build();
+
 	let b = B::from_untyped(s.evaluate_snippet("snip".to_owned(), "{a: 1, c: 2}")?)?;
 	ensure_eq!(b, B { a: 1, b: 2 });
 	ensure_eq!(
@@ -69,8 +73,10 @@
 
 #[test]
 fn flattened_object() -> Result<()> {
-	let s = State::default();
-	s.with_stdlib();
+	let mut s = State::builder();
+	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
+	let s = s.build();
+
 	let obj = Object::from_untyped(
 		s.evaluate_snippet("snip".to_owned(), "{apiVersion: 'ver', kind: 'kind', b: 2}")?,
 	)?;
@@ -100,8 +106,10 @@
 
 #[test]
 fn optional_field_some() -> Result<()> {
-	let s = State::default();
-	s.with_stdlib();
+	let mut s = State::builder();
+	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
+	let s = s.build();
+
 	let c = C::from_untyped(s.evaluate_snippet("snip".to_owned(), "{a: 1, b: 2}")?)?;
 	ensure_eq!(c, C { a: Some(1), b: 2 });
 	ensure_eq!(
@@ -114,8 +122,10 @@
 
 #[test]
 fn optional_field_none() -> Result<()> {
-	let s = State::default();
-	s.with_stdlib();
+	let mut s = State::builder();
+	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
+	let s = s.build();
+
 	let c = C::from_untyped(s.evaluate_snippet("snip".to_owned(), "{b: 2}")?)?;
 	ensure_eq!(c, C { a: None, b: 2 });
 	ensure_eq!(
@@ -140,8 +150,10 @@
 
 #[test]
 fn flatten_optional_some() -> Result<()> {
-	let s = State::default();
-	s.with_stdlib();
+	let mut s = State::builder();
+	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
+	let s = s.build();
+
 	let d = D::from_untyped(s.evaluate_snippet("snip".to_owned(), "{b: 2, v:1}")?)?;
 	ensure_eq!(
 		d,
@@ -160,8 +172,10 @@
 
 #[test]
 fn flatten_optional_none() -> Result<()> {
-	let s = State::default();
-	s.with_stdlib();
+	let mut s = State::builder();
+	s.context_initializer(ContextInitializer::new(PathResolver::new_cwd_fallback()));
+	let s = s.build();
+
 	let d = D::from_untyped(s.evaluate_snippet("snip".to_owned(), "{b: 2, v: '1'}")?)?;
 	ensure_eq!(d, D { e: None, b: 2 });
 	ensure_eq!(