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

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	ToString,205	String,206}207208#[derive(Debug, Clone)]209pub enum Val {210	Bool(bool),211	Null,212	Str(Rc<str>),213	Num(f64),214	Lazy(LazyVal),215	Arr(Rc<Vec<Val>>),216	Obj(ObjValue),217	Func(Rc<FuncVal>),218}219220macro_rules! matches_unwrap {221	($e: expr, $p: pat, $r: expr) => {222		match $e {223			$p => $r,224			_ => panic!("no match"),225			}226	};227}228impl Val {229	/// Creates `Val::Num` after checking for numeric overflow.230	/// As numbers are `f64`, we can just check for their finity.231	pub fn new_checked_num(num: f64) -> Result<Self> {232		if num.is_finite() {233			Ok(Self::Num(num))234		} else {235			throw!(RuntimeError("overflow".into()))236		}237	}238239	pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {240		let this_type = self.value_type()?;241		if this_type != val_type {242			throw!(TypeMismatch(context, vec![val_type], this_type))243		} else {244			Ok(())245		}246	}247	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {248		self.assert_type(context, ValType::Bool)?;249		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Bool(v), v))250	}251	pub fn try_cast_str(self, context: &'static str) -> Result<Rc<str>> {252		self.assert_type(context, ValType::Str)?;253		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Str(v), v))254	}255	pub fn try_cast_num(self, context: &'static str) -> Result<f64> {256		self.assert_type(context, ValType::Num)?;257		Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Num(v), v))258	}259	pub fn inplace_unwrap(&mut self) -> Result<()> {260		while let Self::Lazy(lazy) = self {261			*self = lazy.evaluate()?;262		}263		Ok(())264	}265	pub fn unwrap_if_lazy(&self) -> Result<Self> {266		Ok(if let Self::Lazy(v) = self {267			v.evaluate()?.unwrap_if_lazy()?268		} else {269			self.clone()270		})271	}272	pub fn value_type(&self) -> Result<ValType> {273		Ok(match self {274			Self::Str(..) => ValType::Str,275			Self::Num(..) => ValType::Num,276			Self::Arr(..) => ValType::Arr,277			Self::Obj(..) => ValType::Obj,278			Self::Bool(_) => ValType::Bool,279			Self::Null => ValType::Null,280			Self::Func(..) => ValType::Func,281			Self::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,282		})283	}284285	pub fn to_string(&self) -> Result<Rc<str>> {286		Ok(match self.unwrap_if_lazy()? {287			Self::Bool(true) => "true".into(),288			Self::Bool(false) => "false".into(),289			Self::Null => "null".into(),290			Self::Str(s) => s,291			v => manifest_json_ex(292				&v,293				&ManifestJsonOptions {294					padding: "",295					mtype: ManifestType::ToString,296				},297			)?298			.into(),299		})300	}301302	/// Expects value to be object, outputs (key, manifested value) pairs303	pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(Rc<str>, Rc<str>)>> {304		let obj = match self {305			Self::Obj(obj) => obj,306			_ => throw!(MultiManifestOutputIsNotAObject),307		};308		let keys = obj.visible_fields();309		let mut out = Vec::with_capacity(keys.len());310		for key in keys {311			let value = obj312				.get(key.clone())?313				.expect("item in object")314				.manifest(ty)?;315			out.push((key, value));316		}317		Ok(out)318	}319320	/// Expects value to be array, outputs manifested values321	pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<Rc<str>>> {322		let arr = match self {323			Self::Arr(a) => a,324			_ => throw!(StreamManifestOutputIsNotAArray),325		};326		let mut out = Vec::with_capacity(arr.len());327		for i in arr.iter() {328			out.push(i.manifest(ty)?);329		}330		Ok(out)331	}332333	pub fn manifest(&self, ty: &ManifestFormat) -> Result<Rc<str>> {334		Ok(match ty {335			ManifestFormat::YamlStream(format) => {336				let arr = match self {337					Self::Arr(a) => a,338					_ => throw!(StreamManifestOutputIsNotAArray),339				};340				let mut out = String::new();341342				match format as &ManifestFormat {343					ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),344					ManifestFormat::String => throw!(StreamManifestCannotNestString),345					_ => {}346				};347348				if !arr.is_empty() {349					for v in arr.iter() {350						out.push_str("---\n");351						out.push_str(&v.manifest(format)?);352						out.push_str("\n");353					}354					out.push_str("...");355				}356357				out.into()358			}359			ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,360			ManifestFormat::Json(padding) => self.to_json(*padding)?,361			ManifestFormat::ToString => self.to_string()?,362			ManifestFormat::String => match self {363				Self::Str(s) => s.clone(),364				_ => throw!(StringManifestOutputIsNotAString),365			},366		})367	}368369	/// For manifestification370	pub fn to_json(&self, padding: usize) -> Result<Rc<str>> {371		manifest_json_ex(372			self,373			&ManifestJsonOptions {374				padding: &" ".repeat(padding),375				mtype: if padding == 0 {376					ManifestType::Minify377				} else {378					ManifestType::Manifest379				},380			},381		)382		.map(|s| s.into())383	}384385	/// Calls `std.manifestJson`386	#[cfg(feature = "faster")]387	pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {388		manifest_json_ex(389			self,390			&ManifestJsonOptions {391				padding: &" ".repeat(padding),392				mtype: ManifestType::Std,393			},394		)395		.map(|s| s.into())396	}397398	/// Calls `std.manifestJson`399	#[cfg(not(feature = "faster"))]400	pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {401		with_state(|s| {402			let ctx = s403				.create_default_context()?404				.with_var("__tmp__to_json__".into(), self.clone())?;405			Ok(evaluate(406				ctx,407				&el!(Expr::Apply(408					el!(Expr::Index(409						el!(Expr::Var("std".into())),410						el!(Expr::Str("manifestJsonEx".into()))411					)),412					ArgsDesc(vec![413						Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),414						Arg(None, el!(Expr::Str(" ".repeat(padding).into())))415					]),416					false417				)),418			)?419			.try_cast_str("to json")?)420		})421	}422	pub fn to_yaml(&self, padding: usize) -> Result<Rc<str>> {423		with_state(|s| {424			let ctx = s425				.create_default_context()?426				.with_var("__tmp__to_json__".into(), self.clone());427			Ok(evaluate(428				ctx,429				&el!(Expr::Apply(430					el!(Expr::Index(431						el!(Expr::Var("std".into())),432						el!(Expr::Str("manifestYamlDoc".into()))433					)),434					ArgsDesc(vec![435						Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),436						Arg(437							None,438							el!(Expr::Literal(if padding != 0 {439								LiteralType::True440							} else {441								LiteralType::False442							}))443						)444					]),445					false446				)),447			)?448			.try_cast_str("to json")?)449		})450	}451}452453const fn is_function_like(val: &Val) -> bool {454	matches!(val, Val::Func(_))455}456457/// Native implementation of `std.primitiveEquals`458pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {459	Ok(match (val_a.unwrap_if_lazy()?, val_b.unwrap_if_lazy()?) {460		(Val::Bool(a), Val::Bool(b)) => a == b,461		(Val::Null, Val::Null) => true,462		(Val::Str(a), Val::Str(b)) => a == b,463		(Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,464		(Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(465			"primitiveEquals operates on primitive types, got array".into(),466		)),467		(Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(468			"primitiveEquals operates on primitive types, got object".into(),469		)),470		(a, b) if is_function_like(&a) && is_function_like(&b) => {471			throw!(RuntimeError("cannot test equality of functions".into()))472		}473		(_, _) => false,474	})475}476477/// Native implementation of `std.equals`478pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {479	let val_a = val_a.unwrap_if_lazy()?;480	let val_b = val_b.unwrap_if_lazy()?;481482	if val_a.value_type()? != val_b.value_type()? {483		return Ok(false);484	}485	match (val_a, val_b) {486		// Cant test for ptr equality, because all fields needs to be evaluated487		(Val::Arr(a), Val::Arr(b)) => {488			if a.len() != b.len() {489				return Ok(false);490			}491			for (a, b) in a.iter().zip(b.iter()) {492				if !equals(&a.unwrap_if_lazy()?, &b.unwrap_if_lazy()?)? {493					return Ok(false);494				}495			}496			Ok(true)497		}498		(Val::Obj(a), Val::Obj(b)) => {499			let fields = a.visible_fields();500			if fields != b.visible_fields() {501				return Ok(false);502			}503			for field in fields {504				if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {505					return Ok(false);506				}507			}508			Ok(true)509		}510		(a, b) => Ok(primitive_equals(&a, &b)?),511	}512}