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 80 pub fn evaluate(&self, call_ctx: Context, args: &ArgsDesc, tailstrict: bool) -> Result<Val> {81 let ctx = inline_parse_function_call(82 call_ctx,83 Some(self.ctx.clone()),84 &self.params,85 args,86 tailstrict,87 )?;88 evaluate(ctx, &self.body)89 }9091 pub fn evaluate_values(&self, call_ctx: Context, args: &[Val]) -> Result<Val> {92 let ctx = place_args(call_ctx, Some(self.ctx.clone()), &self.params, args)?;93 evaluate(ctx, &self.body)94 }95}9697#[derive(Debug, Clone)]98pub enum ValType {99 Bool,100 Null,101 Str,102 Num,103 Arr,104 Obj,105 Func,106}107impl ValType {108 pub fn name(&self) -> &'static str {109 use ValType::*;110 match self {111 Bool => "boolean",112 Null => "null",113 Str => "string",114 Num => "number",115 Arr => "array",116 Obj => "object",117 Func => "function",118 }119 }120}121impl Display for ValType {122 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {123 write!(f, "{}", self.name())124 }125}126127#[derive(Debug, PartialEq, Clone)]128pub enum Val {129 Bool(bool),130 Null,131 Str(String),132 Num(f64),133 Lazy(LazyVal),134 Arr(Vec<Val>),135 Obj(ObjValue),136 Func(FuncDesc),137138 139 Intristic(String, String),140}141impl Val {142 pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {143 match self.unwrap_if_lazy()? {144 Val::Bool(v) => Ok(v),145 v => create_error(Error::TypeMismatch(146 context,147 vec![ValType::Bool],148 v.value_type()?,149 )),150 }151 }152 pub fn try_cast_str(self, context: &'static str) -> Result<String> {153 match self.unwrap_if_lazy()? {154 Val::Str(v) => Ok(v),155 v => create_error(Error::TypeMismatch(156 context,157 vec![ValType::Str],158 v.value_type()?,159 )),160 }161 }162 pub fn unwrap_if_lazy(self) -> Result<Self> {163 Ok(if let Val::Lazy(v) = self {164 v.evaluate()?.unwrap_if_lazy()?165 } else {166 self167 })168 }169 pub fn value_type(&self) -> Result<ValType> {170 Ok(match self {171 Val::Str(..) => ValType::Str,172 Val::Num(..) => ValType::Num,173 Val::Arr(..) => ValType::Arr,174 Val::Obj(..) => ValType::Obj,175 Val::Func(..) => ValType::Func,176 Val::Bool(_) => ValType::Bool,177 Val::Null => ValType::Null,178 Val::Intristic(_, _) => ValType::Func,179 Val::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,180 })181 }182 pub fn into_json(self, padding: usize) -> Result<String> {183 with_state(|s| {184 let ctx = s185 .create_default_context()?186 .with_var("__tmp__to_json__".to_owned(), self)?;187 if let Val::Str(result) = evaluate(188 ctx,189 &el!(Expr::Apply(190 el!(Expr::Index(191 el!(Expr::Var("std".to_owned())),192 el!(Expr::Str("manifestJsonEx".to_owned()))193 )),194 ArgsDesc(vec![195 Arg(None, el!(Expr::Var("__tmp__to_json__".to_owned()))),196 Arg(None, el!(Expr::Str(" ".repeat(padding))))197 ]),198 false199 )),200 )? {201 Ok(result)202 } else {203 unreachable!()204 }205 })206 }207}