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

1use crate::{2	create_error, evaluate,3	function::{inline_parse_function_call, place_args},4	with_state, Context, Error, ObjValue, Result,5};6use jsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParamsDesc};7use std::{8	cell::RefCell,9	fmt::{Debug, Display},10	rc::Rc,11};1213struct LazyValInternals {14	pub f: Option<Box<dyn Fn() -> Result<Val>>>,15	pub cached: RefCell<Option<Val>>,16}17#[derive(Clone)]18pub struct LazyVal(Rc<LazyValInternals>);19impl LazyVal {20	pub fn new(f: Box<dyn Fn() -> Result<Val>>) -> Self {21		LazyVal(Rc::new(LazyValInternals {22			f: Some(f),23			cached: RefCell::new(None),24		}))25	}26	pub fn new_resolved(val: Val) -> Self {27		LazyVal(Rc::new(LazyValInternals {28			f: None,29			cached: RefCell::new(Some(val)),30		}))31	}32	pub fn evaluate(&self) -> Result<Val> {33		{34			let cached = self.0.cached.borrow();35			if cached.is_some() {36				return Ok(cached.clone().unwrap());37			}38		}39		let result = (self.0.f.as_ref().unwrap())()?;40		self.0.cached.borrow_mut().replace(result.clone());41		Ok(result)42	}43}4445#[macro_export]46macro_rules! lazy_val {47	($f: expr) => {48		$crate::LazyVal::new(Box::new($f))49	};50}51#[macro_export]52macro_rules! resolved_lazy_val {53	($f: expr) => {54		$crate::LazyVal::new_resolved($f)55	};56}57impl Debug for LazyVal {58	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {59		if self.0.cached.borrow().is_some() {60			write!(f, "{:?}", self.0.cached.borrow().clone().unwrap())61		} else {62			write!(f, "Lazy")63		}64	}65}66impl PartialEq for LazyVal {67	fn eq(&self, other: &Self) -> bool {68		Rc::ptr_eq(&self.0, &other.0)69	}70}7172#[derive(Debug, PartialEq, Clone)]73pub struct FuncDesc {74	pub ctx: Context,75	pub params: ParamsDesc,76	pub body: LocExpr,77}78impl FuncDesc {79	/// This function is always inlined to make tailstrict work80	#[inline(always)]81	pub fn evaluate(&self, call_ctx: Context, args: &ArgsDesc, tailstrict: bool) -> Result<Val> {82		let ctx = inline_parse_function_call(83			call_ctx,84			Some(self.ctx.clone()),85			&self.params,86			args,87			tailstrict,88		)?;89		evaluate(ctx, &self.body)90	}9192	#[inline(always)]93	pub fn evaluate_values(&self, call_ctx: Context, args: &[Val]) -> Result<Val> {94		let ctx = place_args(call_ctx, Some(self.ctx.clone()), &self.params, args)?;95		evaluate(ctx, &self.body)96	}97}9899#[derive(Debug, Clone)]100pub enum ValType {101	Bool,102	Null,103	Str,104	Num,105	Arr,106	Obj,107	Func,108}109impl ValType {110	pub fn name(&self) -> &'static str {111		use ValType::*;112		match self {113			Bool => "boolean",114			Null => "null",115			Str => "string",116			Num => "number",117			Arr => "array",118			Obj => "object",119			Func => "function",120		}121	}122}123impl Display for ValType {124	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {125		write!(f, "{}", self.name())126	}127}128129#[derive(Debug, PartialEq, Clone)]130pub enum Val {131	Bool(bool),132	Null,133	Str(String),134	Num(f64),135	Lazy(LazyVal),136	Arr(Vec<Val>),137	Obj(ObjValue),138	Func(FuncDesc),139140	// Library functions implemented in native141	Intristic(String, String),142}143impl Val {144	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {145		match self.unwrap_if_lazy()? {146			Val::Bool(v) => Ok(v),147			v => create_error(Error::TypeMismatch(148				context,149				vec![ValType::Bool],150				v.value_type()?,151			)),152		}153	}154	pub fn try_cast_str(self, context: &'static str) -> Result<String> {155		match self.unwrap_if_lazy()? {156			Val::Str(v) => Ok(v),157			v => create_error(Error::TypeMismatch(158				context,159				vec![ValType::Str],160				v.value_type()?,161			)),162		}163	}164	pub fn unwrap_if_lazy(self) -> Result<Self> {165		Ok(if let Val::Lazy(v) = self {166			v.evaluate()?.unwrap_if_lazy()?167		} else {168			self169		})170	}171	pub fn value_type(&self) -> Result<ValType> {172		Ok(match self {173			Val::Str(..) => ValType::Str,174			Val::Num(..) => ValType::Num,175			Val::Arr(..) => ValType::Arr,176			Val::Obj(..) => ValType::Obj,177			Val::Func(..) => ValType::Func,178			Val::Bool(_) => ValType::Bool,179			Val::Null => ValType::Null,180			Val::Intristic(_, _) => ValType::Func,181			Val::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,182		})183	}184	pub fn into_json(self, padding: usize) -> Result<String> {185		with_state(|s| {186			let ctx = s187				.create_default_context()?188				.with_var("__tmp__to_json__".to_owned(), self)?;189			if let Val::Str(result) = evaluate(190				ctx,191				&el!(Expr::Apply(192					el!(Expr::Index(193						el!(Expr::Var("std".to_owned())),194						el!(Expr::Str("manifestJsonEx".to_owned()))195					)),196					ArgsDesc(vec![197						Arg(None, el!(Expr::Var("__tmp__to_json__".to_owned()))),198						Arg(None, el!(Expr::Str(" ".repeat(padding))))199					]),200					false201				)),202			)? {203				Ok(result)204			} else {205				unreachable!()206			}207		})208	}209}