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

1//! jsonnet interpreter implementation2#![cfg_attr(feature = "nightly", feature(thread_local, type_alias_impl_trait))]3#![deny(unsafe_op_in_unsafe_fn)]4#![warn(5	clippy::all,6	clippy::nursery,7	clippy::pedantic,8	// missing_docs,9	elided_lifetimes_in_paths,10	explicit_outlives_requirements,11	noop_method_call,12	single_use_lifetimes,13	variant_size_differences,14	rustdoc::all15)]16#![allow(17	macro_expanded_macro_exports_accessed_by_absolute_paths,18	clippy::ptr_arg,19	// Too verbose20	clippy::must_use_candidate,21	// A lot of functions pass around errors thrown by code22	clippy::missing_errors_doc,23	// A lot of pointers have interior Rc24	clippy::needless_pass_by_value,25	// Its fine26	clippy::wildcard_imports,27	clippy::enum_glob_use,28	clippy::module_name_repetitions,29	// TODO: fix individual issues, however this works as intended almost everywhere30	clippy::cast_precision_loss,31	clippy::cast_possible_wrap,32	clippy::cast_possible_truncation,33	clippy::cast_sign_loss,34	// False positives35	// https://github.com/rust-lang/rust-clippy/issues/690236	clippy::use_self,37	// https://github.com/rust-lang/rust-clippy/issues/853938	clippy::iter_with_drain,39	// ci is being run with nightly, but library should work on stable40	clippy::missing_const_for_fn,41)]4243// For jrsonnet-macros44extern crate self as jrsonnet_evaluator;4546mod arr;47#[cfg(feature = "async-import")]48pub mod async_import;49mod ctx;50mod dynamic;51pub mod error;52mod evaluate;53pub mod function;54pub mod gc;55mod import;56mod integrations;57pub mod manifest;58mod map;59mod obj;60pub mod stack;61pub mod stdlib;62mod tla;63pub mod trace;64pub mod typed;65pub mod val;6667use std::{68	any::Any,69	cell::{Ref, RefCell, RefMut},70	fmt::{self, Debug},71	path::Path,72};7374pub use ctx::*;75pub use dynamic::*;76pub use error::{Error, ErrorKind::*, Result, ResultExt};77pub use evaluate::*;78use function::CallLocation;79use gc::{GcHashMap, TraceBox};80use hashbrown::hash_map::RawEntryMut;81pub use import::*;82use jrsonnet_gcmodule::{Cc, Trace};83pub use jrsonnet_interner::{IBytes, IStr};84pub use jrsonnet_parser as parser;85use jrsonnet_parser::*;86pub use obj::*;87use stack::check_depth;88pub use tla::apply_tla;89pub use val::{Thunk, Val};9091/// Thunk without bound `super`/`this`92/// object inheritance may be overriden multiple times, and will be fixed only on field read93pub trait Unbound: Trace {94	/// Type of value after object context is bound95	type Bound;96	/// Create value bound to specified object context97	fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Self::Bound>;98}99100/// Object fields may, or may not depend on `this`/`super`, this enum allows cheaper reuse of object-independent fields for native code101/// Standard jsonnet fields are always unbound102#[derive(Clone, Trace)]103pub enum MaybeUnbound {104	/// Value needs to be bound to `this`/`super`105	Unbound(Cc<TraceBox<dyn Unbound<Bound = Val>>>),106	/// Value is object-independent107	Bound(Thunk<Val>),108}109110impl Debug for MaybeUnbound {111	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {112		write!(f, "MaybeUnbound")113	}114}115impl MaybeUnbound {116	/// Attach object context to value, if required117	pub fn evaluate(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {118		match self {119			Self::Unbound(v) => v.bind(sup, this),120			Self::Bound(v) => Ok(v.evaluate()?),121		}122	}123}124125/// During import, this trait will be called to create initial context for file.126/// It may initialize global variables, stdlib for example.127pub trait ContextInitializer: Trace {128	/// Initialize default file context.129	fn initialize(&self, state: State, for_file: Source) -> Context;130	/// Allows upcasting from abstract to concrete context initializer.131	/// jrsonnet by itself doesn't use this method, it is allowed for it to panic.132	fn as_any(&self) -> &dyn Any;133}134135/// Context initializer which adds nothing.136#[derive(Trace)]137pub struct DummyContextInitializer;138impl ContextInitializer for DummyContextInitializer {139	fn initialize(&self, state: State, _for_file: Source) -> Context {140		ContextBuilder::new(state).build()141	}142	fn as_any(&self) -> &dyn Any {143		self144	}145}146147/// Dynamically reconfigurable evaluation settings148#[derive(Trace)]149pub struct EvaluationSettings {150	/// Context initializer, which will be used for imports and everything151	/// [`NoopContextInitializer`] is used by default, most likely you want to have `jrsonnet-stdlib`152	pub context_initializer: TraceBox<dyn ContextInitializer>,153	/// Used to resolve file locations/contents154	pub import_resolver: TraceBox<dyn ImportResolver>,155}156impl Default for EvaluationSettings {157	fn default() -> Self {158		Self {159			context_initializer: tb!(DummyContextInitializer),160			import_resolver: tb!(DummyImportResolver),161		}162	}163}164165#[derive(Trace)]166struct FileData {167	string: Option<IStr>,168	bytes: Option<IBytes>,169	parsed: Option<LocExpr>,170	evaluated: Option<Val>,171172	evaluating: bool,173}174impl FileData {175	fn new_string(data: IStr) -> Self {176		Self {177			string: Some(data),178			bytes: None,179			parsed: None,180			evaluated: None,181			evaluating: false,182		}183	}184	fn new_bytes(data: IBytes) -> Self {185		Self {186			string: None,187			bytes: Some(data),188			parsed: None,189			evaluated: None,190			evaluating: false,191		}192	}193	pub(crate) fn get_string(&mut self) -> Option<IStr> {194		if self.string.is_none() {195			self.string = Some(196				self.bytes197					.as_ref()198					.expect("either string or bytes should be set")199					.clone()200					.cast_str()?,201			);202		}203		Some(self.string.clone().expect("just set"))204	}205}206207#[derive(Default, Trace)]208pub struct EvaluationStateInternals {209	/// Internal state210	file_cache: RefCell<GcHashMap<SourcePath, FileData>>,211	/// Settings, safe to change at runtime212	settings: RefCell<EvaluationSettings>,213}214215/// Maintains stack trace and import resolution216#[derive(Default, Clone, Trace)]217pub struct State(Cc<EvaluationStateInternals>);218219impl State {220	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise221	pub fn import_resolved_str(&self, path: SourcePath) -> Result<IStr> {222		let mut file_cache = self.file_cache();223		let mut file = file_cache.raw_entry_mut().from_key(&path);224225		let file = match file {226			RawEntryMut::Occupied(ref mut d) => d.get_mut(),227			RawEntryMut::Vacant(v) => {228				let data = self.settings().import_resolver.load_file_contents(&path)?;229				v.insert(230					path.clone(),231					FileData::new_string(232						std::str::from_utf8(&data)233							.map_err(|_| ImportBadFileUtf8(path.clone()))?234							.into(),235					),236				)237				.1238			}239		};240		Ok(file241			.get_string()242			.ok_or_else(|| ImportBadFileUtf8(path.clone()))?)243	}244	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise245	pub fn import_resolved_bin(&self, path: SourcePath) -> Result<IBytes> {246		let mut file_cache = self.file_cache();247		let mut file = file_cache.raw_entry_mut().from_key(&path);248249		let file = match file {250			RawEntryMut::Occupied(ref mut d) => d.get_mut(),251			RawEntryMut::Vacant(v) => {252				let data = self.settings().import_resolver.load_file_contents(&path)?;253				v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))254					.1255			}256		};257		if let Some(str) = &file.bytes {258			return Ok(str.clone());259		}260		if file.bytes.is_none() {261			file.bytes = Some(262				file.string263					.as_ref()264					.expect("either string or bytes should be set")265					.clone()266					.cast_bytes(),267			);268		}269		Ok(file.bytes.as_ref().expect("just set").clone())270	}271	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise272	pub fn import_resolved(&self, path: SourcePath) -> Result<Val> {273		let mut file_cache = self.file_cache();274		let mut file = file_cache.raw_entry_mut().from_key(&path);275276		let file = match file {277			RawEntryMut::Occupied(ref mut d) => d.get_mut(),278			RawEntryMut::Vacant(v) => {279				let data = self.settings().import_resolver.load_file_contents(&path)?;280				v.insert(281					path.clone(),282					FileData::new_string(283						std::str::from_utf8(&data)284							.map_err(|_| ImportBadFileUtf8(path.clone()))?285							.into(),286					),287				)288				.1289			}290		};291		if let Some(val) = &file.evaluated {292			return Ok(val.clone());293		}294		let code = file295			.get_string()296			.ok_or_else(|| ImportBadFileUtf8(path.clone()))?;297		let file_name = Source::new(path.clone(), code.clone());298		if file.parsed.is_none() {299			file.parsed = Some(300				jrsonnet_parser::parse(301					&code,302					&ParserSettings {303						source: file_name.clone(),304					},305				)306				.map_err(|e| ImportSyntaxError {307					path: file_name.clone(),308					error: Box::new(e),309				})?,310			);311		}312		let parsed = file.parsed.as_ref().expect("just set").clone();313		if file.evaluating {314			throw!(InfiniteRecursionDetected)315		}316		file.evaluating = true;317		// Dropping file cache guard here, as evaluation may use this map too318		drop(file_cache);319		let res = evaluate(self.create_default_context(file_name), &parsed);320321		let mut file_cache = self.file_cache();322		let mut file = file_cache.raw_entry_mut().from_key(&path);323324		let RawEntryMut::Occupied(file) = &mut file else {325			unreachable!("this file was just here!")326		};327		let file = file.get_mut();328		file.evaluating = false;329		match res {330			Ok(v) => {331				file.evaluated = Some(v.clone());332				Ok(v)333			}334			Err(e) => Err(e),335		}336	}337338	/// Has same semantics as `import 'path'` called from `from` file339	pub fn import_from(&self, from: &SourcePath, path: &str) -> Result<Val> {340		let resolved = self.resolve_from(from, path)?;341		self.import_resolved(resolved)342	}343	pub fn import(&self, path: impl AsRef<Path>) -> Result<Val> {344		let resolved = self.resolve(path)?;345		self.import_resolved(resolved)346	}347348	/// Creates context with all passed global variables349	pub fn create_default_context(&self, source: Source) -> Context {350		let context_initializer = &self.settings().context_initializer;351		context_initializer.initialize(self.clone(), source)352	}353354	/// Executes code creating a new stack frame355	pub fn push<T>(356		e: CallLocation<'_>,357		frame_desc: impl FnOnce() -> String,358		f: impl FnOnce() -> Result<T>,359	) -> Result<T> {360		let _guard = check_depth()?;361362		f().with_description_src(e, frame_desc)363	}364365	/// Executes code creating a new stack frame366	pub fn push_val(367		&self,368		e: &ExprLocation,369		frame_desc: impl FnOnce() -> String,370		f: impl FnOnce() -> Result<Val>,371	) -> Result<Val> {372		let _guard = check_depth()?;373374		f().with_description_src(e, frame_desc)375	}376	/// Executes code creating a new stack frame377	pub fn push_description<T>(378		frame_desc: impl FnOnce() -> String,379		f: impl FnOnce() -> Result<T>,380	) -> Result<T> {381		let _guard = check_depth()?;382383		f().with_description(frame_desc)384	}385}386387/// Internals388impl State {389	fn file_cache(&self) -> RefMut<'_, GcHashMap<SourcePath, FileData>> {390		self.0.file_cache.borrow_mut()391	}392	pub fn settings(&self) -> Ref<'_, EvaluationSettings> {393		self.0.settings.borrow()394	}395	pub fn settings_mut(&self) -> RefMut<'_, EvaluationSettings> {396		self.0.settings.borrow_mut()397	}398}399400/// Raw methods evaluate passed values but don't perform TLA execution401impl State {402	/// Parses and evaluates the given snippet403	pub fn evaluate_snippet(&self, name: impl Into<IStr>, code: impl Into<IStr>) -> Result<Val> {404		let code = code.into();405		let source = Source::new_virtual(name.into(), code.clone());406		let parsed = jrsonnet_parser::parse(407			&code,408			&ParserSettings {409				source: source.clone(),410			},411		)412		.map_err(|e| ImportSyntaxError {413			path: source.clone(),414			error: Box::new(e),415		})?;416		evaluate(self.create_default_context(source), &parsed)417	}418}419420/// Settings utilities421impl State {422	// Only panics in case of [`ImportResolver`] contract violation423	#[allow(clippy::missing_panics_doc)]424	pub fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {425		self.import_resolver().resolve_from(from, path.as_ref())426	}427428	// Only panics in case of [`ImportResolver`] contract violation429	#[allow(clippy::missing_panics_doc)]430	pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {431		self.import_resolver().resolve(path.as_ref())432	}433	pub fn import_resolver(&self) -> Ref<'_, dyn ImportResolver> {434		Ref::map(self.settings(), |s| &*s.import_resolver)435	}436	pub fn set_import_resolver(&self, resolver: impl ImportResolver) {437		self.settings_mut().import_resolver = tb!(resolver);438	}439	pub fn context_initializer(&self) -> Ref<'_, dyn ContextInitializer> {440		Ref::map(self.settings(), |s| &*s.context_initializer)441	}442	pub fn set_context_initializer(&self, initializer: impl ContextInitializer) {443		self.settings_mut().context_initializer = tb!(initializer);444	}445}