git.delta.rocks / jrsonnet / refs/commits / 7b01ecbd8fbc

1//! jsonnet interpreter implementation2#![cfg_attr(feature = "nightly", feature(thread_local))]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 ctx;47mod dynamic;48pub mod error;49mod evaluate;50pub mod function;51pub mod gc;52mod import;53mod integrations;54mod map;55mod obj;56pub mod stack;57pub mod stdlib;58pub mod trace;59pub mod typed;60pub mod val;6162use std::{63	any::Any,64	cell::{Ref, RefCell, RefMut},65	collections::HashMap,66	fmt::{self, Debug},67	path::Path,68};6970pub use ctx::*;71pub use dynamic::*;72use error::{Error::*, LocError, Result, ResultExt};73pub use evaluate::*;74use function::{CallLocation, TlaArg};75use gc::{GcHashMap, TraceBox};76use hashbrown::hash_map::RawEntryMut;77pub use import::*;78use jrsonnet_gcmodule::{Cc, Trace};79pub use jrsonnet_interner::{IBytes, IStr};80pub use jrsonnet_parser as parser;81use jrsonnet_parser::*;82pub use obj::*;83use stack::check_depth;84use trace::{CompactFormat, TraceFormat};85pub use val::{ManifestFormat, Thunk, Val};8687/// Thunk without bound `super`/`this`88/// object inheritance may be overriden multiple times, and will be fixed only on field read89pub trait Unbound: Trace {90	/// Type of value after object context is bound91	type Bound;92	/// Create value bound to specified object context93	fn bind(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Self::Bound>;94}9596/// Object fields may, or may not depend on `this`/`super`, this enum allows cheaper reuse of object-independent fields for native code97/// Standard jsonnet fields are always unbound98#[derive(Clone, Trace)]99pub enum MaybeUnbound {100	/// Value needs to be bound to `this`/`super`101	Unbound(Cc<TraceBox<dyn Unbound<Bound = Val>>>),102	/// Value is object-independent103	Bound(Thunk<Val>),104}105106impl Debug for MaybeUnbound {107	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {108		write!(f, "MaybeUnbound")109	}110}111impl MaybeUnbound {112	/// Attach object context to value, if required113	pub fn evaluate(&self, sup: Option<ObjValue>, this: Option<ObjValue>) -> Result<Val> {114		match self {115			Self::Unbound(v) => v.bind(sup, this),116			Self::Bound(v) => Ok(v.evaluate()?),117		}118	}119}120121/// During import, this trait will be called to create initial context for file.122/// It may initialize global variables, stdlib for example.123pub trait ContextInitializer: Trace {124	/// Initialize default file context.125	fn initialize(&self, state: State, for_file: Source) -> Context;126	/// Allows upcasting from abstract to concrete context initializer.127	/// jrsonnet by itself doesn't use this method, it is allowed for it to panic.128	fn as_any(&self) -> &dyn Any;129}130131/// Context initializer which adds nothing.132#[derive(Trace)]133pub struct DummyContextInitializer;134impl ContextInitializer for DummyContextInitializer {135	fn initialize(&self, state: State, _for_file: Source) -> Context {136		ContextBuilder::new(state).build()137	}138	fn as_any(&self) -> &dyn Any {139		self140	}141}142143/// Dynamically reconfigurable evaluation settings144#[derive(Trace)]145pub struct EvaluationSettings {146	/// Limits amount of stack trace items preserved147	pub max_trace: usize,148	/// TLA vars149	pub tla_vars: HashMap<IStr, TlaArg>,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	/// Used in manifestification functions156	pub manifest_format: ManifestFormat,157	/// Used for bindings158	pub trace_format: TraceBox<dyn TraceFormat>,159}160impl Default for EvaluationSettings {161	fn default() -> Self {162		Self {163			max_trace: 20,164			context_initializer: tb!(DummyContextInitializer),165			tla_vars: HashMap::default(),166			import_resolver: tb!(DummyImportResolver),167			manifest_format: ManifestFormat::Json {168				padding: 4,169				#[cfg(feature = "exp-preserve-order")]170				preserve_order: false,171			},172			trace_format: tb!(CompactFormat {173				padding: 4,174				resolver: trace::PathResolver::Absolute,175			}),176		}177	}178}179180#[derive(Trace)]181struct FileData {182	string: Option<IStr>,183	bytes: Option<IBytes>,184	parsed: Option<LocExpr>,185	evaluated: Option<Val>,186187	evaluating: bool,188}189impl FileData {190	fn new_string(data: IStr) -> Self {191		Self {192			string: Some(data),193			bytes: None,194			parsed: None,195			evaluated: None,196			evaluating: false,197		}198	}199	fn new_bytes(data: IBytes) -> Self {200		Self {201			string: None,202			bytes: Some(data),203			parsed: None,204			evaluated: None,205			evaluating: false,206		}207	}208}209210#[derive(Default, Trace)]211pub struct EvaluationStateInternals {212	/// Internal state213	file_cache: RefCell<GcHashMap<SourcePath, FileData>>,214	/// Settings, safe to change at runtime215	settings: RefCell<EvaluationSettings>,216}217218/// Maintains stack trace and import resolution219#[derive(Default, Clone, Trace)]220pub struct State(Cc<EvaluationStateInternals>);221222impl State {223	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise224	pub fn import_resolved_str(&self, path: SourcePath) -> Result<IStr> {225		let mut file_cache = self.file_cache();226		let mut file = file_cache.raw_entry_mut().from_key(&path);227228		let file = match file {229			RawEntryMut::Occupied(ref mut d) => d.get_mut(),230			RawEntryMut::Vacant(v) => {231				let data = self.settings().import_resolver.load_file_contents(&path)?;232				v.insert(233					path.clone(),234					FileData::new_string(235						std::str::from_utf8(&data)236							.map_err(|_| ImportBadFileUtf8(path.clone()))?237							.into(),238					),239				)240				.1241			}242		};243		if let Some(str) = &file.string {244			return Ok(str.clone());245		}246		if file.string.is_none() {247			file.string = Some(248				file.bytes249					.as_ref()250					.expect("either string or bytes should be set")251					.clone()252					.cast_str()253					.ok_or_else(|| ImportBadFileUtf8(path.clone()))?,254			);255		}256		Ok(file.string.as_ref().expect("just set").clone())257	}258	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise259	pub fn import_resolved_bin(&self, path: SourcePath) -> Result<IBytes> {260		let mut file_cache = self.file_cache();261		let mut file = file_cache.raw_entry_mut().from_key(&path);262263		let file = match file {264			RawEntryMut::Occupied(ref mut d) => d.get_mut(),265			RawEntryMut::Vacant(v) => {266				let data = self.settings().import_resolver.load_file_contents(&path)?;267				v.insert(path.clone(), FileData::new_bytes(data.as_slice().into()))268					.1269			}270		};271		if let Some(str) = &file.bytes {272			return Ok(str.clone());273		}274		if file.bytes.is_none() {275			file.bytes = Some(276				file.string277					.as_ref()278					.expect("either string or bytes should be set")279					.clone()280					.cast_bytes(),281			);282		}283		Ok(file.bytes.as_ref().expect("just set").clone())284	}285	/// Should only be called with path retrieved from [`resolve_path`], may panic otherwise286	pub fn import_resolved(&self, path: SourcePath) -> Result<Val> {287		let mut file_cache = self.file_cache();288		let mut file = file_cache.raw_entry_mut().from_key(&path);289290		let file = match file {291			RawEntryMut::Occupied(ref mut d) => d.get_mut(),292			RawEntryMut::Vacant(v) => {293				let data = self.settings().import_resolver.load_file_contents(&path)?;294				v.insert(295					path.clone(),296					FileData::new_string(297						std::str::from_utf8(&data)298							.map_err(|_| ImportBadFileUtf8(path.clone()))?299							.into(),300					),301				)302				.1303			}304		};305		if let Some(val) = &file.evaluated {306			return Ok(val.clone());307		}308		if file.string.is_none() {309			file.string = Some(310				std::str::from_utf8(311					file.bytes312						.as_ref()313						.expect("either string or bytes should be set"),314				)315				.map_err(|_| ImportBadFileUtf8(path.clone()))?316				.into(),317			);318		}319		let code = file.string.as_ref().expect("just set");320		let file_name = Source::new(path.clone(), code.clone());321		if file.parsed.is_none() {322			file.parsed = Some(323				jrsonnet_parser::parse(324					code,325					&ParserSettings {326						file_name: file_name.clone(),327					},328				)329				.map_err(|e| ImportSyntaxError {330					path: file_name.clone(),331					error: Box::new(e),332				})?,333			);334		}335		let parsed = file.parsed.as_ref().expect("just set").clone();336		if file.evaluating {337			throw!(InfiniteRecursionDetected)338		}339		file.evaluating = true;340		// Dropping file cache guard here, as evaluation may use this map too341		drop(file_cache);342		let res = evaluate(self.create_default_context(file_name), &parsed);343344		let mut file_cache = self.file_cache();345		let mut file = file_cache.raw_entry_mut().from_key(&path);346347		let RawEntryMut::Occupied(file) = &mut file else {348			unreachable!("this file was just here!")349		};350		let file = file.get_mut();351		file.evaluating = false;352		match res {353			Ok(v) => {354				file.evaluated = Some(v.clone());355				Ok(v)356			}357			Err(e) => Err(e),358		}359	}360361	/// Has same semantics as `import 'path'` called from `from` file362	pub fn import_from(&self, from: &SourcePath, path: &str) -> Result<Val> {363		let resolved = self.resolve_from(from, path)?;364		self.import_resolved(resolved)365	}366	pub fn import(&self, path: impl AsRef<Path>) -> Result<Val> {367		let resolved = self.resolve(path)?;368		self.import_resolved(resolved)369	}370371	/// Creates context with all passed global variables372	pub fn create_default_context(&self, source: Source) -> Context {373		let context_initializer = &self.settings().context_initializer;374		context_initializer.initialize(self.clone(), source)375	}376377	/// Executes code creating a new stack frame378	pub fn push<T>(379		e: CallLocation<'_>,380		frame_desc: impl FnOnce() -> String,381		f: impl FnOnce() -> Result<T>,382	) -> Result<T> {383		let _guard = check_depth()?;384385		f().with_description_src(e, frame_desc)386	}387388	/// Executes code creating a new stack frame389	pub fn push_val(390		&self,391		e: &ExprLocation,392		frame_desc: impl FnOnce() -> String,393		f: impl FnOnce() -> Result<Val>,394	) -> Result<Val> {395		let _guard = check_depth()?;396397		f().with_description_src(e, frame_desc)398	}399	/// Executes code creating a new stack frame400	pub fn push_description<T>(401		frame_desc: impl FnOnce() -> String,402		f: impl FnOnce() -> Result<T>,403	) -> Result<T> {404		let _guard = check_depth()?;405406		f().with_description(frame_desc)407	}408409	/// # Panics410	/// In case of formatting failure411	pub fn stringify_err(&self, e: &LocError) -> String {412		let mut out = String::new();413		self.settings()414			.trace_format415			.write_trace(&mut out, self, e)416			.unwrap();417		out418	}419420	pub fn manifest(&self, val: Val) -> Result<IStr> {421		Self::push_description(422			|| "manifestification".to_string(),423			|| val.manifest(&self.manifest_format()),424		)425	}426	pub fn manifest_multi(&self, val: Val) -> Result<Vec<(IStr, IStr)>> {427		val.manifest_multi(&self.manifest_format())428	}429	pub fn manifest_stream(&self, val: Val) -> Result<Vec<IStr>> {430		val.manifest_stream(&self.manifest_format())431	}432433	/// If passed value is function then call with set TLA434	pub fn with_tla(&self, val: Val) -> Result<Val> {435		Ok(match val {436			Val::Func(func) => State::push_description(437				|| "during TLA call".to_owned(),438				|| {439					func.evaluate(440						self.create_default_context(Source::new_virtual(441							"<tla>".into(),442							IStr::empty(),443						)),444						CallLocation::native(),445						&self.settings().tla_vars,446						true,447					)448				},449			)?,450			v => v,451		})452	}453}454455/// Internals456impl State {457	fn file_cache(&self) -> RefMut<'_, GcHashMap<SourcePath, FileData>> {458		self.0.file_cache.borrow_mut()459	}460	pub fn settings(&self) -> Ref<'_, EvaluationSettings> {461		self.0.settings.borrow()462	}463	pub fn settings_mut(&self) -> RefMut<'_, EvaluationSettings> {464		self.0.settings.borrow_mut()465	}466}467468/// Raw methods evaluate passed values but don't perform TLA execution469impl State {470	/// Parses and evaluates the given snippet471	pub fn evaluate_snippet(&self, name: impl Into<IStr>, code: impl Into<IStr>) -> Result<Val> {472		let code = code.into();473		let source = Source::new_virtual(name.into(), code.clone());474		let parsed = jrsonnet_parser::parse(475			&code,476			&ParserSettings {477				file_name: source.clone(),478			},479		)480		.map_err(|e| ImportSyntaxError {481			path: source.clone(),482			error: Box::new(e),483		})?;484		evaluate(self.create_default_context(source), &parsed)485	}486}487488/// Settings utilities489impl State {490	pub fn add_tla(&self, name: IStr, value: Val) {491		self.settings_mut()492			.tla_vars493			.insert(name, TlaArg::Val(value));494	}495	pub fn add_tla_str(&self, name: IStr, value: IStr) {496		self.settings_mut()497			.tla_vars498			.insert(name, TlaArg::String(value));499	}500	pub fn add_tla_code(&self, name: IStr, code: &str) -> Result<()> {501		let source_name = format!("<top-level-arg:{name}>");502		let source = Source::new_virtual(source_name.into(), code.into());503		let parsed = jrsonnet_parser::parse(504			code,505			&ParserSettings {506				file_name: source.clone(),507			},508		)509		.map_err(|e| ImportSyntaxError {510			path: source,511			error: Box::new(e),512		})?;513		self.settings_mut()514			.tla_vars515			.insert(name, TlaArg::Code(parsed));516		Ok(())517	}518519	// Only panics in case of [`ImportResolver`] contract violation520	#[allow(clippy::missing_panics_doc)]521	pub fn resolve_from(&self, from: &SourcePath, path: &str) -> Result<SourcePath> {522		self.import_resolver().resolve_from(from, path.as_ref())523	}524525	// Only panics in case of [`ImportResolver`] contract violation526	#[allow(clippy::missing_panics_doc)]527	pub fn resolve(&self, path: impl AsRef<Path>) -> Result<SourcePath> {528		self.import_resolver().resolve(path.as_ref())529	}530	pub fn import_resolver(&self) -> Ref<'_, dyn ImportResolver> {531		Ref::map(self.settings(), |s| &*s.import_resolver)532	}533	pub fn set_import_resolver(&self, resolver: Box<dyn ImportResolver>) {534		self.settings_mut().import_resolver = TraceBox(resolver);535	}536	pub fn context_initializer(&self) -> Ref<'_, dyn ContextInitializer> {537		Ref::map(self.settings(), |s| &*s.context_initializer)538	}539540	pub fn manifest_format(&self) -> ManifestFormat {541		self.settings().manifest_format.clone()542	}543	pub fn set_manifest_format(&self, format: ManifestFormat) {544		self.settings_mut().manifest_format = format;545	}546547	pub fn trace_format(&self) -> Ref<'_, dyn TraceFormat> {548		Ref::map(self.settings(), |s| &*s.trace_format)549	}550	pub fn set_trace_format(&self, format: impl TraceFormat) {551		self.settings_mut().trace_format = tb!(format);552	}553554	pub fn max_trace(&self) -> usize {555		self.settings().max_trace556	}557	pub fn set_max_trace(&self, trace: usize) {558		self.settings_mut().max_trace = trace;559	}560}