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

517517
518[[package]]518[[package]]
519name = "serde"519name = "serde"
520version = "1.0.137"520version = "1.0.142"
521source = "registry+https://github.com/rust-lang/crates.io-index"521source = "registry+https://github.com/rust-lang/crates.io-index"
522checksum = "61ea8d54c77f8315140a05f4c7237403bf38b72704d031543aa1d16abbf517d1"522checksum = "e590c437916fb6b221e1d00df6e3294f3fccd70ca7e92541c475d6ed6ef5fee2"
523dependencies = [523dependencies = [
524 "serde_derive",524 "serde_derive",
525]525]
526526
527[[package]]527[[package]]
528name = "serde_derive"528name = "serde_derive"
529version = "1.0.137"529version = "1.0.142"
530source = "registry+https://github.com/rust-lang/crates.io-index"530source = "registry+https://github.com/rust-lang/crates.io-index"
531checksum = "1f26faba0c3959972377d3b2d306ee9f71faee9714294e41bb777f83f88578be"531checksum = "34b5b8d809babe02f538c2cfec6f2c1ed10804c0e5a6a041a049a4f5588ccc2e"
532dependencies = [532dependencies = [
533 "proc-macro2",533 "proc-macro2",
534 "quote",534 "quote",
619 "winapi-util",619 "winapi-util",
620]620]
621
622[[package]]
623name = "tests"
624version = "0.1.0"
625dependencies = [
626 "jrsonnet-evaluator",
627 "jrsonnet-gcmodule",
628 "jrsonnet-stdlib",
629 "serde",
630]
621631
622[[package]]632[[package]]
623name = "textwrap"633name = "textwrap"

1[workspace]1[workspace]
2members = ["crates/*", "bindings/jsonnet", "cmds/jrsonnet"]2members = ["crates/*", "bindings/jsonnet", "cmds/jrsonnet", "tests"]
33
4[profile.test]4[profile.test]
5opt-level = 15opt-level = 1

139	}139	}
140}140}
141141
142#[derive(Default)]
143pub struct ContextBuilder {142pub struct ContextBuilder {
144	bindings: GcHashMap<IStr, Thunk<Val>>,143	bindings: GcHashMap<IStr, Thunk<Val>>,
144	extend: Option<Context>,
145}145}
146
146impl ContextBuilder {147impl ContextBuilder {
147	pub fn new() -> Self {148	pub fn new() -> Self {
148		Self::default()149		Self::with_capacity(0)
149	}150	}
150	pub fn with_capacity(capacity: usize) -> Self {151	pub fn with_capacity(capacity: usize) -> Self {
151		Self {152		Self {
152			bindings: GcHashMap::with_capacity(capacity),153			bindings: GcHashMap::with_capacity(capacity),
154			extend: None,
153		}155		}
154	}156	}
157	pub fn extend(parent: Context) -> Self {
158		Self {
159			bindings: GcHashMap::new(),
160			extend: Some(parent),
161		}
162	}
155	pub fn bind(&mut self, name: IStr, value: Thunk<Val>) -> &mut Self {163	pub fn bind(&mut self, name: IStr, value: Thunk<Val>) -> &mut Self {
156		self.bindings.insert(name, value);164		self.bindings.insert(name, value);
157		self165		self
158	}166	}
159	pub fn build(self) -> Context {167	pub fn build(self) -> Context {
168		if let Some(parent) = self.extend {
169			parent.extend(self.bindings, None, None, None)
170		} else {
160		Context(Cc::new(ContextInternals {171			Context(Cc::new(ContextInternals {
161			bindings: LayeredHashMap::new(self.bindings),172				bindings: LayeredHashMap::new(self.bindings),
162			dollar: None,173				dollar: None,
163			sup: None,174				sup: None,
164			this: None,175				this: None,
165		}))176			}))
166	}177		}
178	}
167}179}
180
181impl Default for ContextBuilder {
182	fn default() -> Self {
183		Self::new()
184	}
185}
168186

22
3use jrsonnet_gcmodule::{Cc, Trace};3use jrsonnet_gcmodule::{Cc, Trace};
44
5// TODO: Replace with OnceCell once in std
5#[derive(Clone, Trace)]6#[derive(Clone, Trace)]
6pub struct Pending<V: Trace + 'static>(pub Cc<RefCell<Option<V>>>);7pub struct Pending<V: Trace + 'static>(pub Cc<RefCell<Option<V>>>);
7impl<T: Trace + 'static> Pending<T> {8impl<T: Trace + 'static> Pending<T> {

362pub mod tests {362pub mod tests {
363	use std::borrow::Cow;363	use std::borrow::Cow;
364364
365	use jrsonnet_interner::IStr;
365	use BinaryOpType::*;366	use BinaryOpType::*;
366367
367	use super::{expr::*, parse};368	use super::{expr::*, parse};
372			parse(373			parse(
373				$s,374				$s,
374				&ParserSettings {375				&ParserSettings {
375					file_name: Source::new_virtual(Cow::Borrowed("<test>")),376					file_name: Source::new_virtual(Cow::Borrowed("<test>"), IStr::empty()),
376				},377				},
377			)378			)
378			.unwrap()379			.unwrap()
384			LocExpr(385			LocExpr(
385				std::rc::Rc::new($expr),386				std::rc::Rc::new($expr),
386				ExprLocation(Source::new_virtual(Cow::Borrowed("<test>")), $from, $to),387				ExprLocation(
388					Source::new_virtual(Cow::Borrowed("<test>"), IStr::empty()),
389					$from,
390					$to,
391				),
712		parse!("local x(foo = 'foo', bar) = null; null");717		parse!("local x(foo = 'foo', bar) = null; null");
713	}718	}
714
715	#[test]
716	fn can_parse_stdlib() {
717		parse!(jrsonnet_stdlib::STDLIB_STR);
718	}
719719
720	#[test]720	#[test]
721	fn add_location_info_to_all_sub_expressions() {721	fn add_location_info_to_all_sub_expressions() {
722		use Expr::*;722		use Expr::*;
723723
724		let file_name = Source::new_virtual(Cow::Borrowed("<test>"));724		let file_name = Source::new_virtual(Cow::Borrowed("<test>"), IStr::empty());
725		let expr = parse(725		let expr = parse(
726			"{} { local x = 1, x: x } + {}",726			"{} { local x = 1, x: x } + {}",
727			&ParserSettings { file_name },727			&ParserSettings { file_name },

8use jrsonnet_evaluator::{8use jrsonnet_evaluator::{
9	error::{Error::*, Result},9	error::{Error::*, Result},
10	function::{builtin::Builtin, ArgLike, CallLocation, FuncVal, TlaArg},10	function::{builtin::Builtin, ArgLike, CallLocation, FuncVal, TlaArg},
11	gc::TraceBox,11	gc::{GcHashMap, TraceBox},
12	tb, throw_runtime,12	tb, throw_runtime,
13	typed::{Any, Either, Either2, Either4, VecVal, M1},13	typed::{Any, Either, Either2, Either4, VecVal, M1},
14	val::{equals, ArrValue},14	val::{equals, ArrValue},
201	pub ext_vars: HashMap<IStr, TlaArg>,201	pub ext_vars: HashMap<IStr, TlaArg>,
202	/// Used for `std.native`202	/// Used for `std.native`
203	pub ext_natives: HashMap<IStr, Cc<TraceBox<dyn Builtin>>>,203	pub ext_natives: HashMap<IStr, Cc<TraceBox<dyn Builtin>>>,
204	/// Helper to add globals without implementing custom ContextInitializer
205	pub globals: GcHashMap<IStr, Thunk<Val>>,
204	/// Used for `std.trace`206	/// Used for `std.trace`
205	pub trace_printer: Box<dyn TracePrinter>,207	pub trace_printer: Box<dyn TracePrinter>,
206}208}
210		Self {212		Self {
211			ext_vars: Default::default(),213			ext_vars: Default::default(),
212			ext_natives: Default::default(),214			ext_natives: Default::default(),
215			globals: Default::default(),
213			trace_printer: Box::new(StdTracePrinter),216			trace_printer: Box::new(StdTracePrinter),
214		}217		}
215	}218	}
289impl jrsonnet_evaluator::ContextInitializer for ContextInitializer {292impl jrsonnet_evaluator::ContextInitializer for ContextInitializer {
290	#[cfg(not(feature = "legacy-this-file"))]293	#[cfg(not(feature = "legacy-this-file"))]
291	fn initialize(&self, _s: State, _source: Source) -> jrsonnet_evaluator::Context {294	fn initialize(&self, _s: State, _source: Source) -> jrsonnet_evaluator::Context {
292		self.context.clone()295		let out = self.context.clone();
296		let globals = &self.settings().globals;
297		if globals.is_empty() {
298			return out;
299		}
300
301		let mut out = ContextBuilder::extend(out);
302		for (k, v) in globals.iter() {
303			out.bind(k.clone(), v.clone());
304		}
305		out.build()
293	}306	}
294	#[cfg(feature = "legacy-this-file")]307	#[cfg(feature = "legacy-this-file")]
295	fn initialize(&self, s: State, source: Source) -> jrsonnet_evaluator::Context {308	fn initialize(&self, s: State, source: Source) -> jrsonnet_evaluator::Context {
316			"std".into(),329			"std".into(),
317			Thunk::evaluated(Val::Obj(stdlib_with_this_file)),330			Thunk::evaluated(Val::Obj(stdlib_with_this_file)),
318		);331		);
332		for (k, v) in &self.settings().globals {
333			context.bind(k.clone(), v.clone())
334		}
319		context.build()335		context.build()
320	}336	}
321	unsafe fn as_any(&self) -> &dyn std::any::Any {337	unsafe fn as_any(&self) -> &dyn std::any::Any {
514	})530	})
515}531}
532
533pub trait StateExt {
534	/// This method was previously implemented in jrsonnet-evaluator itself
535	fn with_stdlib(&self);
536	fn add_global(&self, name: IStr, value: Thunk<Val>);
537}
538
539impl StateExt for State {
540	fn with_stdlib(&self) {
541		let initializer = ContextInitializer::new(self.clone());
542		self.settings_mut().context_initializer = Box::new(initializer)
543	}
544	fn add_global(&self, name: IStr, value: Thunk<Val>) {
545		// Safety:
546		unsafe { self.settings().context_initializer.as_any() }
547			.downcast_ref::<ContextInitializer>()
548			.expect("not standard context initializer")
549			.settings_mut()
550			.globals
551			.insert(name, value);
552	}
553}
516554