1use crate::{2 builtin::manifest::{manifest_json_ex, ManifestJsonOptions, ManifestType},3 error::Error::*,4 evaluate,5 function::{parse_function_call, parse_function_call_map, place_args},6 throw, with_state, Context, ObjValue, Result,7};8use jrsonnet_parser::{el, Arg, ArgsDesc, Expr, LocExpr, ParamsDesc};9use std::{10 cell::RefCell,11 collections::HashMap,12 fmt::{Debug, Display},13 rc::Rc,14};1516enum LazyValInternals {17 Computed(Val),18 Waiting(Box<dyn Fn() -> Result<Val>>),19}20#[derive(Clone)]21pub struct LazyVal(Rc<RefCell<LazyValInternals>>);22impl LazyVal {23 pub fn new(f: Box<dyn Fn() -> Result<Val>>) -> Self {24 LazyVal(Rc::new(RefCell::new(LazyValInternals::Waiting(f))))25 }26 pub fn new_resolved(val: Val) -> Self {27 LazyVal(Rc::new(RefCell::new(LazyValInternals::Computed(val))))28 }29 pub fn evaluate(&self) -> Result<Val> {30 let new_value = match &*self.0.borrow() {31 LazyValInternals::Computed(v) => return Ok(v.clone()),32 LazyValInternals::Waiting(f) => f()?,33 };34 *self.0.borrow_mut() = LazyValInternals::Computed(new_value.clone());35 Ok(new_value)36 }37}3839#[macro_export]40macro_rules! lazy_val {41 ($f: expr) => {42 $crate::LazyVal::new(Box::new($f))43 };44}45#[macro_export]46macro_rules! resolved_lazy_val {47 ($f: expr) => {48 $crate::LazyVal::new_resolved($f)49 };50}51impl Debug for LazyVal {52 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {53 write!(f, "Lazy")54 }55}56impl PartialEq for LazyVal {57 fn eq(&self, other: &Self) -> bool {58 Rc::ptr_eq(&self.0, &other.0)59 }60}6162#[derive(Debug, PartialEq)]63pub struct FuncDesc {64 pub name: Rc<str>,65 pub ctx: Context,66 pub params: ParamsDesc,67 pub body: LocExpr,68}69impl FuncDesc {70 71 pub fn evaluate(&self, call_ctx: Context, args: &ArgsDesc, tailstrict: bool) -> Result<Val> {72 let ctx = parse_function_call(73 call_ctx,74 Some(self.ctx.clone()),75 &self.params,76 args,77 tailstrict,78 )?;79 evaluate(ctx, &self.body)80 }8182 pub fn evaluate_map(83 &self,84 call_ctx: Context,85 args: &HashMap<Rc<str>, Val>,86 tailstrict: bool,87 ) -> Result<Val> {88 let ctx = parse_function_call_map(89 call_ctx,90 Some(self.ctx.clone()),91 &self.params,92 args,93 tailstrict,94 )?;95 evaluate(ctx, &self.body)96 }9798 pub fn evaluate_values(&self, call_ctx: Context, args: &[Val]) -> Result<Val> {99 let ctx = place_args(call_ctx, Some(self.ctx.clone()), &self.params, args)?;100 evaluate(ctx, &self.body)101 }102}103104#[derive(Debug, Clone, Copy, PartialEq)]105pub enum ValType {106 Bool,107 Null,108 Str,109 Num,110 Arr,111 Obj,112 Func,113}114impl ValType {115 pub fn name(&self) -> &'static str {116 use ValType::*;117 match self {118 Bool => "boolean",119 Null => "null",120 Str => "string",121 Num => "number",122 Arr => "array",123 Obj => "object",124 Func => "function",125 }126 }127}128impl Display for ValType {129 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {130 write!(f, "{}", self.name())131 }132}133134#[derive(Clone)]135pub enum ManifestFormat {136 YamlStream(Box<ManifestFormat>),137 Yaml(usize),138 Json(usize),139 String,140}141142#[derive(Debug, Clone)]143pub enum Val {144 Bool(bool),145 Null,146 Str(Rc<str>),147 Num(f64),148 Lazy(LazyVal),149 Arr(Rc<Vec<Val>>),150 Obj(ObjValue),151 Func(Rc<FuncDesc>),152153 154 Intristic(Rc<str>, Rc<str>),155}156macro_rules! matches_unwrap {157 ($e: expr, $p: pat, $r: expr) => {158 match $e {159 $p => $r,160 _ => panic!("no match"),161 }162 };163}164impl Val {165 166 pub fn new_checked_num(num: f64) -> Result<Val> {167 if num.is_finite() {168 Ok(Val::Num(num))169 } else {170 throw!(RuntimeError("overflow".into()))171 }172 }173174 pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {175 let this_type = self.value_type()?;176 if this_type != val_type {177 throw!(TypeMismatch(context, vec![val_type], this_type))178 } else {179 Ok(())180 }181 }182 pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {183 self.assert_type(context, ValType::Bool)?;184 Ok(matches_unwrap!(self.unwrap_if_lazy()?, Val::Bool(v), v))185 }186 pub fn try_cast_str(self, context: &'static str) -> Result<Rc<str>> {187 self.assert_type(context, ValType::Str)?;188 Ok(matches_unwrap!(self.unwrap_if_lazy()?, Val::Str(v), v))189 }190 pub fn try_cast_num(self, context: &'static str) -> Result<f64> {191 self.assert_type(context, ValType::Num)?;192 Ok(matches_unwrap!(self.unwrap_if_lazy()?, Val::Num(v), v))193 }194 pub fn unwrap_if_lazy(&self) -> Result<Self> {195 Ok(if let Val::Lazy(v) = self {196 v.evaluate()?.unwrap_if_lazy()?197 } else {198 self.clone()199 })200 }201 pub fn value_type(&self) -> Result<ValType> {202 Ok(match self {203 Val::Str(..) => ValType::Str,204 Val::Num(..) => ValType::Num,205 Val::Arr(..) => ValType::Arr,206 Val::Obj(..) => ValType::Obj,207 Val::Func(..) => ValType::Func,208 Val::Bool(_) => ValType::Bool,209 Val::Null => ValType::Null,210 Val::Intristic(_, _) => ValType::Func,211 Val::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,212 })213 }214215 pub fn into_string(self) -> Result<Rc<str>> {216 Ok(match self.unwrap_if_lazy()? {217 Val::Bool(true) => "true".into(),218 Val::Bool(false) => "false".into(),219 Val::Null => "null".into(),220 Val::Str(s) => s,221 v => manifest_json_ex(222 &v,223 &ManifestJsonOptions {224 padding: &"",225 mtype: ManifestType::ToString,226 },227 )?228 .into(),229 })230 }231232233 pub fn manifest(&self, ty: &ManifestFormat) -> Result<Rc<str>> {234 Ok(match ty {235 ManifestFormat::YamlStream(format) => {236 let arr = match self {237 Val::Arr(a) => a,238 _ => throw!(StreamManifestOutputIsNotAArray),239 };240 let mut out = String::new();241242 match format as &ManifestFormat {243 ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),244 ManifestFormat::String => throw!(StreamManifestCannotNestString),245 _ => {}246 };247248 if !arr.is_empty() {249 for v in arr.iter() {250 out.push_str("---\n");251 out.push_str(&v.manifest(format)?);252 out.push_str("\n");253 }254 out.push_str("...");255 }256257 out.into()258 }259 ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,260 ManifestFormat::Json(padding) => self.to_json(*padding)?,261 ManifestFormat::String => match self {262 Val::Str(s) => s.clone(),263 _ => throw!(StringManifestOutputIsNotAString),264 },265 })266 }267268 269 pub fn to_json(&self, padding: usize) -> Result<Rc<str>> {270 manifest_json_ex(271 self,272 &ManifestJsonOptions {273 padding: &" ".repeat(padding),274 mtype: if padding == 0 {275 ManifestType::Minify276 } else {277 ManifestType::Manifest278 },279 },280 )281 .map(|s| s.into())282 }283284 285 #[cfg(feature = "faster")]286 pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {287 manifest_json_ex(288 &self,289 &ManifestJsonOptions {290 padding: &" ".repeat(padding),291 mtype: ManifestType::Std,292 },293 )294 .map(|s| s.into())295 }296297 298 #[cfg(not(feature = "faster"))]299 pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {300 with_state(|s| {301 let ctx = s302 .create_default_context()?303 .with_var("__tmp__to_json__".into(), self.clone())?;304 Ok(evaluate(305 ctx,306 &el!(Expr::Apply(307 el!(Expr::Index(308 el!(Expr::Var("std".into())),309 el!(Expr::Str("manifestJsonEx".into()))310 )),311 ArgsDesc(vec![312 Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),313 Arg(None, el!(Expr::Str(" ".repeat(padding).into())))314 ]),315 false316 )),317 )?318 .try_cast_str("to json")?)319 })320 }321 pub fn to_yaml(&self, padding: usize) -> Result<Rc<str>> {322 with_state(|s| {323 let ctx = s324 .create_default_context()?325 .with_var("__tmp__to_json__".into(), self.clone());326 Ok(evaluate(327 ctx,328 &el!(Expr::Apply(329 el!(Expr::Index(330 el!(Expr::Var("std".into())),331 el!(Expr::Str("manifestYamlDoc".into()))332 )),333 ArgsDesc(vec![334 Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),335 Arg(None, el!(Expr::Str(" ".repeat(padding).into())))336 ]),337 false338 )),339 )?340 .try_cast_str("to json")?)341 })342 }343}344345fn is_function_like(val: &Val) -> bool {346 matches!(val, Val::Func(_) | Val::Intristic(_, _))347}348349350pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {351 Ok(match (val_a.unwrap_if_lazy()?, val_b.unwrap_if_lazy()?) {352 (Val::Bool(a), Val::Bool(b)) => a == b,353 (Val::Null, Val::Null) => true,354 (Val::Str(a), Val::Str(b)) => a == b,355 (Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,356 (Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(357 "primitiveEquals operates on primitive types, got array".into(),358 )),359 (Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(360 "primitiveEquals operates on primitive types, got object".into(),361 )),362 (a, b) if is_function_like(&a) && is_function_like(&b) => {363 throw!(RuntimeError("cannot test equality of functions".into()))364 }365 (_, _) => false,366 })367}368369370pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {371 let val_a = val_a.unwrap_if_lazy()?;372 let val_b = val_b.unwrap_if_lazy()?;373374 if val_a.value_type()? != val_b.value_type()? {375 return Ok(false);376 }377 match (val_a, val_b) {378 379 (Val::Arr(a), Val::Arr(b)) => {380 if a.len() != b.len() {381 return Ok(false);382 }383 for (a, b) in a.iter().zip(b.iter()) {384 if !equals(&a.unwrap_if_lazy()?, &b.unwrap_if_lazy()?)? {385 return Ok(false);386 }387 }388 Ok(true)389 }390 (Val::Obj(a), Val::Obj(b)) => {391 let fields = a.visible_fields();392 if fields != b.visible_fields() {393 return Ok(false);394 }395 for field in fields {396 if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {397 return Ok(false);398 }399 }400 Ok(true)401 }402 (a, b) => Ok(primitive_equals(&a, &b)?),403 }404}