difftreelog
refactor drop interior mutable settings from State
in: master
9 files changed
crates/jrsonnet-evaluator/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-evaluator/src/lib.rs
+++ b/crates/jrsonnet-evaluator/src/lib.rs
@@ -27,7 +27,7 @@
use std::{
any::Any,
- cell::{Ref, RefCell, RefMut},
+ cell::{RefCell, RefMut},
fmt::{self, Debug},
path::Path,
};
@@ -145,24 +145,6 @@
}
impl_context_initializer! {
A @ B C D E F G
-}
-
-/// Dynamically reconfigurable evaluation settings
-#[derive(Trace)]
-pub struct EvaluationSettings {
- /// Context initializer, which will be used for imports and everything
- /// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`
- pub context_initializer: TraceBox<dyn ContextInitializer>,
- /// Used to resolve file locations/contents
- pub import_resolver: TraceBox<dyn ImportResolver>,
-}
-impl Default for EvaluationSettings {
- fn default() -> Self {
- Self {
- context_initializer: tb!(()),
- import_resolver: tb!(DummyImportResolver),
- }
- }
}
#[derive(Trace)]
@@ -207,16 +189,19 @@
}
}
-#[derive(Default, Trace)]
+#[derive(Trace)]
pub struct EvaluationStateInternals {
/// Internal state
file_cache: RefCell<GcHashMap<SourcePath, FileData>>,
- /// Settings, safe to change at runtime
- settings: RefCell<EvaluationSettings>,
+ /// Context initializer, which will be used for imports and everything
+ /// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`
+ context_initializer: TraceBox<dyn ContextInitializer>,
+ /// Used to resolve file locations/contents
+ import_resolver: TraceBox<dyn ImportResolver>,
}
/// Maintains stack trace and import resolution
-#[derive(Default, Clone, Trace)]
+#[derive(Clone, Trace)]
pub struct State(Cc<EvaluationStateInternals>);
impl State {
@@ -228,7 +213,7 @@
let file = match file {
RawEntryMut::Occupied(ref mut d) => d.get_mut(),
RawEntryMut::Vacant(v) => {
- let data = self.settings().import_resolver.load_file_contents(&path)?;
+ let data = self.import_resolver().load_file_contents(&path)?;
v.insert(
path.clone(),
FileData::new_string(
@@ -252,7 +237,7 @@
let file = match file {
RawEntryMut::Occupied(ref mut d) => d.get_mut(),
RawEntryMut::Vacant(v) => {
- let data = self.settings().import_resolver.load_file_contents(&path)?;
+ let data = self.import_resolver().load_file_contents(&path)?;
v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))
.1
}
@@ -279,7 +264,7 @@
let file = match file {
RawEntryMut::Occupied(ref mut d) => d.get_mut(),
RawEntryMut::Vacant(v) => {
- let data = self.settings().import_resolver.load_file_contents(&path)?;
+ let data = self.import_resolver().load_file_contents(&path)?;
v.insert(
path.clone(),
FileData::new_string(
@@ -350,8 +335,7 @@
/// Creates context with all passed global variables
pub fn create_default_context(&self, source: Source) -> Context {
- let context_initializer = &self.settings().context_initializer;
- context_initializer.initialize(self.clone(), source)
+ self.context_initializer().initialize(self.clone(), source)
}
/// Creates context with all passed global variables, calling custom modifier
@@ -360,7 +344,7 @@
source: Source,
context_initializer: impl ContextInitializer,
) -> Context {
- let default_initializer = &self.settings().context_initializer;
+ let default_initializer = self.context_initializer();
let mut builder = ContextBuilder::with_capacity(
self.clone(),
default_initializer.reserve_vars() + context_initializer.reserve_vars(),
@@ -408,49 +392,6 @@
impl State {
fn file_cache(&self) -> RefMut<'_, GcHashMap<SourcePath, FileData>> {
self.0.file_cache.borrow_mut()
- }
- pub fn settings(&self) -> Ref<'_, EvaluationSettings> {
- self.0.settings.borrow()
- }
- pub fn settings_mut(&self) -> RefMut<'_, EvaluationSettings> {
- self.0.settings.borrow_mut()
- }
- pub fn add_global(&self, name: IStr, value: Thunk<Val>) {
- #[derive(Trace)]
- struct GlobalsCtx {
- globals: RefCell<GcHashMap<IStr, Thunk<Val>>>,
- inner: TraceBox<dyn ContextInitializer>,
- }
- impl ContextInitializer for GlobalsCtx {
- fn reserve_vars(&self) -> usize {
- self.inner.reserve_vars() + self.globals.borrow().len()
- }
- fn populate(&self, for_file: Source, builder: &mut ContextBuilder) {
- self.inner.populate(for_file, builder);
- for (name, val) in self.globals.borrow().iter() {
- builder.bind(name.clone(), val.clone());
- }
- }
-
- fn as_any(&self) -> &dyn Any {
- self
- }
- }
- let mut settings = self.settings_mut();
- let initializer = &mut settings.context_initializer;
- if let Some(global) = initializer.as_any().downcast_ref::<GlobalsCtx>() {
- global.globals.borrow_mut().insert(name, value);
- } else {
- let inner = std::mem::replace(&mut settings.context_initializer, tb!(()));
- settings.context_initializer = tb!(GlobalsCtx {
- globals: {
- let mut out = GcHashMap::with_capacity(1);
- out.insert(name, value);
- RefCell::new(out)
- },
- inner
- });
- }
}
}
@@ -523,16 +464,51 @@
pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {
self.import_resolver().resolve(path.as_ref())
}
- pub fn import_resolver(&self) -> Ref<'_, dyn ImportResolver> {
- Ref::map(self.settings(), |s| &*s.import_resolver)
+ pub fn import_resolver(&self) -> &dyn ImportResolver {
+ &*self.0.import_resolver
+ }
+ pub fn context_initializer(&self) -> &dyn ContextInitializer {
+ &*self.0.context_initializer
+ }
+}
+
+impl State {
+ pub fn builder() -> StateBuilder {
+ StateBuilder::default()
+ }
+}
+
+impl Default for State {
+ fn default() -> Self {
+ Self::builder().build()
}
- pub fn set_import_resolver(&self, resolver: impl ImportResolver) {
- self.settings_mut().import_resolver = tb!(resolver);
+}
+
+#[derive(Default)]
+pub struct StateBuilder {
+ import_resolver: Option<TraceBox<dyn ImportResolver>>,
+ context_initializer: Option<TraceBox<dyn ContextInitializer>>,
+}
+impl StateBuilder {
+ pub fn import_resolver(&mut self, import_resolver: impl ImportResolver) -> &mut Self {
+ let _ = self.import_resolver.insert(tb!(import_resolver));
+ self
}
- pub fn context_initializer(&self) -> Ref<'_, dyn ContextInitializer> {
- Ref::map(self.settings(), |s| &*s.context_initializer)
+ pub fn context_initializer(
+ &mut self,
+ context_initializer: impl ContextInitializer,
+ ) -> &mut Self {
+ let _ = self.context_initializer.insert(tb!(context_initializer));
+ self
}
- pub fn set_context_initializer(&self, initializer: impl ContextInitializer) {
- self.settings_mut().context_initializer = tb!(initializer);
+ pub fn build(mut self) -> State {
+ State(Cc::new(EvaluationStateInternals {
+ file_cache: RefCell::new(GcHashMap::new()),
+ context_initializer: self.context_initializer.take().unwrap_or_else(|| tb!(())),
+ import_resolver: self
+ .import_resolver
+ .take()
+ .unwrap_or_else(|| tb!(DummyImportResolver)),
+ }))
}
}
tests/tests/as_native.rsdiffbeforeafterboth--- 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)>();
tests/tests/builtin.rsdiffbeforeafterboth--- 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(),
tests/tests/common.rsdiffbeforeafterboth--- 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
+ }
}
tests/tests/golden.rsdiffbeforeafterboth1use std::{2 fs, io,3 path::{Path, PathBuf},4};56use jrsonnet_evaluator::{7 manifest::JsonFormat,8 trace::{CompactFormat, PathResolver, TraceFormat},9 FileImportResolver, State,10};11use jrsonnet_stdlib::StateExt;12mod common;1314fn run(file: &Path) -> String {15 let s = State::default();16 s.with_stdlib();17 common::with_test(&s);18 s.set_import_resolver(FileImportResolver::default());19 let trace_format = CompactFormat {20 resolver: PathResolver::FileName,21 max_trace: 20,22 padding: 4,23 };2425 let v = match s.import(file) {26 Ok(v) => v,27 Err(e) => return trace_format.format(&e).unwrap(),28 };29 match v.manifest(JsonFormat::default()) {30 Ok(v) => v.to_string(),31 Err(e) => trace_format.format(&e).unwrap(),32 }33}3435#[test]36fn test() -> io::Result<()> {37 use json_structural_diff::JsonDiff;3839 let mut root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));40 root.push("golden");4142 for entry in fs::read_dir(&root)? {43 let entry = entry?;44 if !entry.path().extension().map_or(false, |e| e == "jsonnet") {45 continue;46 }4748 let result = run(&entry.path());4950 let mut golden_path = entry.path();51 golden_path.set_extension("jsonnet.golden");5253 if !golden_path.exists() {54 fs::write(golden_path, &result)?;55 } else {56 let golden = fs::read_to_string(golden_path)?;5758 match (serde_json::from_str(&result), serde_json::from_str(&golden)) {59 (Err(_), Ok(_)) => assert_eq!(60 result,61 golden,62 "unexpected error for golden {}",63 entry.path().display()64 ),65 (Ok(_), Err(_)) => assert_eq!(66 result,67 golden,68 "expected error for golden {}",69 entry.path().display()70 ),71 (Ok(result), Ok(golden)) => {72 // Show diff relative to golden`.73 let diff = JsonDiff::diff_string(&golden, &result, false);74 if let Some(diff) = diff {75 panic!(76 "Result \n{result:#}\n\77 and golden \n{golden:#}\n\78 did not match structurally:\n{diff:#}\n\79 for golden {}",80 entry.path().display()81 );82 }83 }84 (Err(_), Err(_)) => {}85 };8687 assert_eq!(88 result,89 golden,90 "golden didn't match for {}",91 entry.path().display()92 )93 }94 }9596 Ok(())97}tests/tests/sanity.rsdiffbeforeafterboth--- 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(())
tests/tests/std_native.rsdiffbeforeafterboth--- 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")
tests/tests/suite.rsdiffbeforeafterboth--- 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) {
tests/tests/typed_obj.rsdiffbeforeafterboth--- 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!(