git.delta.rocks / jrsonnet / refs/commits / 712f0045bec7

1use crate::{2	builtin::{3		call_builtin,4		manifest::{manifest_json_ex, ManifestJsonOptions, ManifestType},5	},6	error::Error::*,7	evaluate,8	function::{parse_function_call, parse_function_call_map, place_args},9	native::NativeCallback,10	throw, with_state, Context, ObjValue, Result,11};12use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, ExprLocation, LiteralType, LocExpr, ParamsDesc};13use std::{14	cell::RefCell,15	collections::HashMap,16	fmt::{Debug, Display},17	rc::Rc,18};1920enum LazyValInternals {21	Computed(Val),22	Waiting(Box<dyn Fn() -> Result<Val>>),23}24#[derive(Clone)]25pub struct LazyVal(Rc<RefCell<LazyValInternals>>);26impl LazyVal {27	pub fn new(f: Box<dyn Fn() -> Result<Val>>) -> Self {28		Self(Rc::new(RefCell::new(LazyValInternals::Waiting(f))))29	}30	pub fn new_resolved(val: Val) -> Self {31		Self(Rc::new(RefCell::new(LazyValInternals::Computed(val))))32	}33	pub fn evaluate(&self) -> Result<Val> {34		let new_value = match &*self.0.borrow() {35			LazyValInternals::Computed(v) => return Ok(v.clone()),36			LazyValInternals::Waiting(f) => f()?,37		};38		*self.0.borrow_mut() = LazyValInternals::Computed(new_value.clone());39		Ok(new_value)40	}41}4243#[macro_export]44macro_rules! lazy_val {45	($f: expr) => {46		$crate::LazyVal::new(Box::new($f))47	};48}49#[macro_export]50macro_rules! resolved_lazy_val {51	($f: expr) => {52		$crate::LazyVal::new_resolved($f)53	};54}55impl Debug for LazyVal {56	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {57		write!(f, "Lazy")58	}59}60impl PartialEq for LazyVal {61	fn eq(&self, other: &Self) -> bool {62		Rc::ptr_eq(&self.0, &other.0)63	}64}6566#[derive(Debug, PartialEq)]67pub struct FuncDesc {68	pub name: Rc<str>,69	pub ctx: Context,70	pub params: ParamsDesc,71	pub body: LocExpr,72}7374#[derive(Debug)]75pub enum FuncVal {76	/// Plain function implemented in jsonnet77	Normal(FuncDesc),78	/// Standard library function79	Intrinsic(Rc<str>, Rc<str>),80	/// Library functions implemented in native81	NativeExt(Rc<str>, Rc<NativeCallback>),82}8384impl PartialEq for FuncVal {85	fn eq(&self, other: &Self) -> bool {86		match (self, other) {87			(Self::Normal(a), Self::Normal(b)) => a == b,88			(Self::Intrinsic(ans, an), Self::Intrinsic(bns, bn)) => ans == bns && an == bn,89			(Self::NativeExt(an, _), Self::NativeExt(bn, _)) => an == bn,90			(..) => false,91		}92	}93}94impl FuncVal {95	pub fn is_ident(&self) -> bool {96		matches!(&self, Self::Intrinsic(ns, n) if ns as &str == "std" && n as &str == "id")97	}98	pub fn name(&self) -> Rc<str> {99		match self {100			Self::Normal(normal) => normal.name.clone(),101			Self::Intrinsic(ns, name) => format!("intrinsic.{}.{}", ns, name).into(),102			Self::NativeExt(n, _) => format!("native.{}", n).into(),103		}104	}105	pub fn evaluate(106		&self,107		call_ctx: Context,108		loc: &Option<ExprLocation>,109		args: &ArgsDesc,110		tailstrict: bool,111	) -> Result<Val> {112		match self {113			Self::Normal(func) => {114				let ctx = parse_function_call(115					call_ctx,116					Some(func.ctx.clone()),117					&func.params,118					args,119					tailstrict,120				)?;121				evaluate(ctx, &func.body)122			}123			Self::Intrinsic(ns, name) => call_builtin(call_ctx, loc, ns, name, args),124			Self::NativeExt(_name, handler) => {125				let args = parse_function_call(call_ctx, None, &handler.params, args, true)?;126				let mut out_args = Vec::with_capacity(handler.params.len());127				for p in handler.params.0.iter() {128					out_args.push(args.binding(p.0.clone())?.evaluate()?);129				}130				Ok(handler.call(&out_args)?)131			}132		}133	}134135	pub fn evaluate_map(136		&self,137		call_ctx: Context,138		args: &HashMap<Rc<str>, Val>,139		tailstrict: bool,140	) -> Result<Val> {141		match self {142			Self::Normal(func) => {143				let ctx = parse_function_call_map(144					call_ctx,145					Some(func.ctx.clone()),146					&func.params,147					args,148					tailstrict,149				)?;150				evaluate(ctx, &func.body)151			}152			Self::Intrinsic(_, _) => todo!(),153			Self::NativeExt(_, _) => todo!(),154		}155	}156157	pub fn evaluate_values(&self, call_ctx: Context, args: &[Val]) -> Result<Val> {158		match self {159			Self::Normal(func) => {160				let ctx = place_args(call_ctx, Some(func.ctx.clone()), &func.params, args)?;161				evaluate(ctx, &func.body)162			}163			Self::Intrinsic(_, _) => todo!(),164			Self::NativeExt(_, _) => todo!(),165		}166	}167}168169#[derive(Debug, Clone, Copy, PartialEq)]170pub enum ValType {171	Bool,172	Null,173	Str,174	Num,175	Arr,176	Obj,177	Func,178}179impl ValType {180	pub const fn name(&self) -> &'static str {181		use ValType::*;182		match self {183			Bool => "boolean",184			Null => "null",185			Str => "string",186			Num => "number",187			Arr => "array",188			Obj => "object",189			Func => "function",190		}191	}192}193impl Display for ValType {194	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {195		write!(f, "{}", self.name())196	}197}198199#[derive(Clone)]200pub enum ManifestFormat {201	YamlStream(Box<ManifestFormat>),202	Yaml(usize),203	Json(usize),204	String,205}206207#[derive(Debug, Clone)]208pub enum Val {209	Bool(bool),210	Null,211	Str(Rc<str>),212	Num(f64),213	Lazy(LazyVal),214	Arr(Rc<Vec<Val>>),215	Obj(ObjValue),216	Func(Rc<FuncVal>),217}218219macro_rules! matches_unwrap {220	($e: expr, $p: pat, $r: expr) => {221		match $e {222			$p => $r,223			_ => panic!("no match"),224			}225	};226}227impl Val {228	/// Creates `Val::Num` after checking for numeric overflow.229	/// As numbers are `f64`, we can just check for their finity.230	pub fn new_checked_num(num: f64) -> Result<Self> {231		if num.is_finite() {232			Ok(Self::Num(num))233		} else {234			throw!(RuntimeError("overflow".into()))235		}236	}237238	pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {239		let this_type = self.value_type()?;240		if this_type != val_type {241			throw!(TypeMismatch(context, vec![val_type], this_type))242		} else {243			Ok(())244		}245	}246	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {247		self.assert_type(context, ValType::Bool)?;248		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Bool(v), v))249	}250	pub fn try_cast_str(self, context: &'static str) -> Result<Rc<str>> {251		self.assert_type(context, ValType::Str)?;252		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Str(v), v))253	}254	pub fn try_cast_num(self, context: &'static str) -> Result<f64> {255		self.assert_type(context, ValType::Num)?;256		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Num(v), v))257	}258	pub fn inplace_unwrap(&mut self) -> Result<()> {259		while let Self::Lazy(lazy) = self {260			*self = lazy.evaluate()?;261		}262		Ok(())263	}264	pub fn unwrap_if_lazy(&self) -> Result<Self> {265		Ok(if let Self::Lazy(v) = self {266			v.evaluate()?.unwrap_if_lazy()?267		} else {268			self.clone()269		})270	}271	pub fn value_type(&self) -> Result<ValType> {272		Ok(match self {273			Self::Str(..) => ValType::Str,274			Self::Num(..) => ValType::Num,275			Self::Arr(..) => ValType::Arr,276			Self::Obj(..) => ValType::Obj,277			Self::Bool(_) => ValType::Bool,278			Self::Null => ValType::Null,279			Self::Func(..) => ValType::Func,280			Self::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,281		})282	}283284	pub fn to_string(&self) -> Result<Rc<str>> {285		Ok(match self.unwrap_if_lazy()? {286			Self::Bool(true) => "true".into(),287			Self::Bool(false) => "false".into(),288			Self::Null => "null".into(),289			Self::Str(s) => s,290			v => manifest_json_ex(291				&v,292				&ManifestJsonOptions {293					padding: "",294					mtype: ManifestType::ToString,295				},296			)?297			.into(),298		})299	}300301	/// Expects value to be object, outputs (key, manifested value) pairs302	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(Rc<str>, Rc<str>)>> {303		let obj = match self {304			Self::Obj(obj) => obj,305			_ => throw!(MultiManifestOutputIsNotAObject),306		};307		let keys = obj.visible_fields();308		let mut out = Vec::with_capacity(keys.len());309		for key in keys {310			let value = obj311				.get(key.clone())?312				.expect("item in object")313				.manifest(ty)?;314			out.push((key, value));315		}316		Ok(out)317	}318319	/// Expects value to be array, outputs manifested values320	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<Rc<str>>> {321		let arr = match self {322			Self::Arr(a) => a,323			_ => throw!(StreamManifestOutputIsNotAArray),324		};325		let mut out = Vec::with_capacity(arr.len());326		for i in arr.iter() {327			out.push(i.manifest(ty)?);328		}329		Ok(out)330	}331332	pub fn manifest(&self, ty: &ManifestFormat) -> Result<Rc<str>> {333		Ok(match ty {334			ManifestFormat::YamlStream(format) => {335				let arr = match self {336					Self::Arr(a) => a,337					_ => throw!(StreamManifestOutputIsNotAArray),338				};339				let mut out = String::new();340341				match format as &ManifestFormat {342					ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),343					ManifestFormat::String => throw!(StreamManifestCannotNestString),344					_ => {}345				};346347				if !arr.is_empty() {348					for v in arr.iter() {349						out.push_str("---\n");350						out.push_str(&v.manifest(format)?);351						out.push_str("\n");352					}353					out.push_str("...");354				}355356				out.into()357			}358			ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,359			ManifestFormat::Json(padding) => self.to_json(*padding)?,360			ManifestFormat::String => match self {361				Self::Str(s) => s.clone(),362				_ => throw!(StringManifestOutputIsNotAString),363			},364		})365	}366367	/// For manifestification368	pub fn to_json(&self, padding: usize) -> Result<Rc<str>> {369		manifest_json_ex(370			self,371			&ManifestJsonOptions {372				padding: &" ".repeat(padding),373				mtype: if padding == 0 {374					ManifestType::Minify375				} else {376					ManifestType::Manifest377				},378			},379		)380		.map(|s| s.into())381	}382383	/// Calls `std.manifestJson`384	#[cfg(feature = "faster")]385	pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {386		manifest_json_ex(387			self,388			&ManifestJsonOptions {389				padding: &" ".repeat(padding),390				mtype: ManifestType::Std,391			},392		)393		.map(|s| s.into())394	}395396	/// Calls `std.manifestJson`397	#[cfg(not(feature = "faster"))]398	pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {399		with_state(|s| {400			let ctx = s401				.create_default_context()?402				.with_var("__tmp__to_json__".into(), self.clone())?;403			Ok(evaluate(404				ctx,405				&el!(Expr::Apply(406					el!(Expr::Index(407						el!(Expr::Var("std".into())),408						el!(Expr::Str("manifestJsonEx".into()))409					)),410					ArgsDesc(vec![411						Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),412						Arg(None, el!(Expr::Str(" ".repeat(padding).into())))413					]),414					false415				)),416			)?417			.try_cast_str("to json")?)418		})419	}420	pub fn to_yaml(&self, padding: usize) -> Result<Rc<str>> {421		with_state(|s| {422			let ctx = s423				.create_default_context()?424				.with_var("__tmp__to_json__".into(), self.clone());425			Ok(evaluate(426				ctx,427				&el!(Expr::Apply(428					el!(Expr::Index(429						el!(Expr::Var("std".into())),430						el!(Expr::Str("manifestYamlDoc".into()))431					)),432					ArgsDesc(vec![433						Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),434						Arg(435							None,436							el!(Expr::Literal(if padding != 0 {437								LiteralType::True438							} else {439								LiteralType::False440							}))441						)442					]),443					false444				)),445			)?446			.try_cast_str("to json")?)447		})448	}449}450451const fn is_function_like(val: &Val) -> bool {452	matches!(val, Val::Func(_))453}454455/// Native implementation of `std.primitiveEquals`456pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {457	Ok(match (val_a.unwrap_if_lazy()?, val_b.unwrap_if_lazy()?) {458		(Val::Bool(a), Val::Bool(b)) => a == b,459		(Val::Null, Val::Null) => true,460		(Val::Str(a), Val::Str(b)) => a == b,461		(Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,462		(Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(463			"primitiveEquals operates on primitive types, got array".into(),464		)),465		(Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(466			"primitiveEquals operates on primitive types, got object".into(),467		)),468		(a, b) if is_function_like(&a) && is_function_like(&b) => {469			throw!(RuntimeError("cannot test equality of functions".into()))470		}471		(_, _) => false,472	})473}474475/// Native implementation of `std.equals`476pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {477	let val_a = val_a.unwrap_if_lazy()?;478	let val_b = val_b.unwrap_if_lazy()?;479480	if val_a.value_type()? != val_b.value_type()? {481		return Ok(false);482	}483	match (val_a, val_b) {484		// Cant test for ptr equality, because all fields needs to be evaluated485		(Val::Arr(a), Val::Arr(b)) => {486			if a.len() != b.len() {487				return Ok(false);488			}489			for (a, b) in a.iter().zip(b.iter()) {490				if !equals(&a.unwrap_if_lazy()?, &b.unwrap_if_lazy()?)? {491					return Ok(false);492				}493			}494			Ok(true)495		}496		(Val::Obj(a), Val::Obj(b)) => {497			let fields = a.visible_fields();498			if fields != b.visible_fields() {499				return Ok(false);500			}501			for field in fields {502				if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {503					return Ok(false);504				}505			}506			Ok(true)507		}508		(a, b) => Ok(primitive_equals(&a, &b)?),509	}510}