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, 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 LazyVal(Rc::new(RefCell::new(LazyValInternals::Waiting(f))))29 }30 pub fn new_resolved(val: Val) -> Self {31 LazyVal(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, Clone)]75pub enum FuncVal {76 77 Normal(Rc<FuncDesc>),78 79 Intristic(Rc<str>, Rc<str>),80 81 NativeExt(Rc<str>, Rc<NativeCallback>),82}83impl PartialEq for FuncVal {84 fn eq(&self, other: &Self) -> bool {85 match (self, other) {86 (FuncVal::Normal(a), FuncVal::Normal(b)) => a == b,87 (FuncVal::Intristic(ans, an), FuncVal::Intristic(bns, bn)) => ans == bns && an == bn,88 (FuncVal::NativeExt(an, _), FuncVal::NativeExt(bn, _)) => an == bn,89 (..) => false,90 }91 }92}93impl FuncVal {94 pub fn is_ident(&self) -> bool {95 matches!(&self, FuncVal::Intristic(ns, n) if ns as &str == "std" && n as &str == "id")96 }97 pub fn name(&self) -> Rc<str> {98 match self {99 FuncVal::Normal(normal) => normal.name.clone(),100 FuncVal::Intristic(ns, name) => format!("intristic.{}.{}", ns, name).into(),101 FuncVal::NativeExt(n, _) => format!("native.{}", n).into(),102 }103 }104 pub fn evaluate(105 &self,106 call_ctx: Context,107 loc: &Option<ExprLocation>,108 args: &ArgsDesc,109 tailstrict: bool,110 ) -> Result<Val> {111 match self {112 FuncVal::Normal(func) => {113 let ctx = parse_function_call(114 call_ctx,115 Some(func.ctx.clone()),116 &func.params,117 args,118 tailstrict,119 )?;120 evaluate(ctx, &func.body)121 }122 FuncVal::Intristic(ns, name) => call_builtin(call_ctx, loc, &ns, &name, args),123 FuncVal::NativeExt(_name, handler) => {124 let args = parse_function_call(call_ctx, None, &handler.params, args, true)?;125 let mut out_args = Vec::with_capacity(handler.params.len());126 for p in handler.params.0.iter() {127 out_args.push(args.binding(p.0.clone())?.evaluate()?);128 }129 Ok(handler.call(&out_args)?)130 }131 }132 }133134 pub fn evaluate_map(135 &self,136 call_ctx: Context,137 args: &HashMap<Rc<str>, Val>,138 tailstrict: bool,139 ) -> Result<Val> {140 match self {141 FuncVal::Normal(func) => {142 let ctx = parse_function_call_map(143 call_ctx,144 Some(func.ctx.clone()),145 &func.params,146 args,147 tailstrict,148 )?;149 evaluate(ctx, &func.body)150 }151 FuncVal::Intristic(_, _) => todo!(),152 FuncVal::NativeExt(_, _) => todo!(),153 }154 }155156 pub fn evaluate_values(&self, call_ctx: Context, args: &[Val]) -> Result<Val> {157 match self {158 FuncVal::Normal(func) => {159 let ctx = place_args(call_ctx, Some(func.ctx.clone()), &func.params, args)?;160 evaluate(ctx, &func.body)161 }162 FuncVal::Intristic(_, _) => todo!(),163 FuncVal::NativeExt(_, _) => todo!(),164 }165 }166}167168#[derive(Debug, Clone, Copy, PartialEq)]169pub enum ValType {170 Bool,171 Null,172 Str,173 Num,174 Arr,175 Obj,176 Func,177}178impl ValType {179 pub fn name(&self) -> &'static str {180 use ValType::*;181 match self {182 Bool => "boolean",183 Null => "null",184 Str => "string",185 Num => "number",186 Arr => "array",187 Obj => "object",188 Func => "function",189 }190 }191}192impl Display for ValType {193 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {194 write!(f, "{}", self.name())195 }196}197198#[derive(Clone)]199pub enum ManifestFormat {200 YamlStream(Box<ManifestFormat>),201 Yaml(usize),202 Json(usize),203 String,204}205206#[derive(Debug, Clone)]207pub enum Val {208 Bool(bool),209 Null,210 Str(Rc<str>),211 Num(f64),212 Lazy(LazyVal),213 Arr(Rc<Vec<Val>>),214 Obj(ObjValue),215 Func(FuncVal),216}217macro_rules! matches_unwrap {218 ($e: expr, $p: pat, $r: expr) => {219 match $e {220 $p => $r,221 _ => panic!("no match"),222 }223 };224}225impl Val {226 227 pub fn new_checked_num(num: f64) -> Result<Val> {228 if num.is_finite() {229 Ok(Val::Num(num))230 } else {231 throw!(RuntimeError("overflow".into()))232 }233 }234235 pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {236 let this_type = self.value_type()?;237 if this_type != val_type {238 throw!(TypeMismatch(context, vec![val_type], this_type))239 } else {240 Ok(())241 }242 }243 pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {244 self.assert_type(context, ValType::Bool)?;245 Ok(matches_unwrap!(self.unwrap_if_lazy()?, Val::Bool(v), v))246 }247 pub fn try_cast_str(self, context: &'static str) -> Result<Rc<str>> {248 self.assert_type(context, ValType::Str)?;249 Ok(matches_unwrap!(self.unwrap_if_lazy()?, Val::Str(v), v))250 }251 pub fn try_cast_num(self, context: &'static str) -> Result<f64> {252 self.assert_type(context, ValType::Num)?;253 Ok(matches_unwrap!(self.unwrap_if_lazy()?, Val::Num(v), v))254 }255 pub fn inplace_unwrap(&mut self) -> Result<()> {256 while let Val::Lazy(lazy) = self {257 *self = lazy.evaluate()?;258 }259 Ok(())260 }261 pub fn unwrap_if_lazy(&self) -> Result<Self> {262 Ok(if let Val::Lazy(v) = self {263 v.evaluate()?.unwrap_if_lazy()?264 } else {265 self.clone()266 })267 }268 pub fn value_type(&self) -> Result<ValType> {269 Ok(match self {270 Val::Str(..) => ValType::Str,271 Val::Num(..) => ValType::Num,272 Val::Arr(..) => ValType::Arr,273 Val::Obj(..) => ValType::Obj,274 Val::Bool(_) => ValType::Bool,275 Val::Null => ValType::Null,276 Val::Func(..) => ValType::Func,277 Val::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,278 })279 }280281 pub fn to_string(&self) -> Result<Rc<str>> {282 Ok(match self.unwrap_if_lazy()? {283 Val::Bool(true) => "true".into(),284 Val::Bool(false) => "false".into(),285 Val::Null => "null".into(),286 Val::Str(s) => s,287 v => manifest_json_ex(288 &v,289 &ManifestJsonOptions {290 padding: &"",291 mtype: ManifestType::ToString,292 },293 )?294 .into(),295 })296 }297298 299 pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(Rc<str>, Rc<str>)>> {300 let obj = match self {301 Val::Obj(obj) => obj,302 _ => throw!(MultiManifestOutputIsNotAObject),303 };304 let keys = obj.visible_fields();305 let mut out = Vec::with_capacity(keys.len());306 for key in keys {307 let value = obj308 .get(key.clone())?309 .expect("item in object")310 .manifest(ty)?;311 out.push((key, value));312 }313 Ok(out)314 }315316 317 pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<Rc<str>>> {318 let arr = match self {319 Val::Arr(a) => a,320 _ => throw!(StreamManifestOutputIsNotAArray),321 };322 let mut out = Vec::with_capacity(arr.len());323 for i in arr.iter() {324 out.push(i.manifest(ty)?);325 }326 Ok(out)327 }328329 pub fn manifest(&self, ty: &ManifestFormat) -> Result<Rc<str>> {330 Ok(match ty {331 ManifestFormat::YamlStream(format) => {332 let arr = match self {333 Val::Arr(a) => a,334 _ => throw!(StreamManifestOutputIsNotAArray),335 };336 let mut out = String::new();337338 match format as &ManifestFormat {339 ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),340 ManifestFormat::String => throw!(StreamManifestCannotNestString),341 _ => {}342 };343344 if !arr.is_empty() {345 for v in arr.iter() {346 out.push_str("---\n");347 out.push_str(&v.manifest(format)?);348 out.push_str("\n");349 }350 out.push_str("...");351 }352353 out.into()354 }355 ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,356 ManifestFormat::Json(padding) => self.to_json(*padding)?,357 ManifestFormat::String => match self {358 Val::Str(s) => s.clone(),359 _ => throw!(StringManifestOutputIsNotAString),360 },361 })362 }363364 365 pub fn to_json(&self, padding: usize) -> Result<Rc<str>> {366 manifest_json_ex(367 self,368 &ManifestJsonOptions {369 padding: &" ".repeat(padding),370 mtype: if padding == 0 {371 ManifestType::Minify372 } else {373 ManifestType::Manifest374 },375 },376 )377 .map(|s| s.into())378 }379380 381 #[cfg(feature = "faster")]382 pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {383 manifest_json_ex(384 &self,385 &ManifestJsonOptions {386 padding: &" ".repeat(padding),387 mtype: ManifestType::Std,388 },389 )390 .map(|s| s.into())391 }392393 394 #[cfg(not(feature = "faster"))]395 pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {396 with_state(|s| {397 let ctx = s398 .create_default_context()?399 .with_var("__tmp__to_json__".into(), self.clone())?;400 Ok(evaluate(401 ctx,402 &el!(Expr::Apply(403 el!(Expr::Index(404 el!(Expr::Var("std".into())),405 el!(Expr::Str("manifestJsonEx".into()))406 )),407 ArgsDesc(vec![408 Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),409 Arg(None, el!(Expr::Str(" ".repeat(padding).into())))410 ]),411 false412 )),413 )?414 .try_cast_str("to json")?)415 })416 }417 pub fn to_yaml(&self, padding: usize) -> Result<Rc<str>> {418 with_state(|s| {419 let ctx = s420 .create_default_context()?421 .with_var("__tmp__to_json__".into(), self.clone());422 Ok(evaluate(423 ctx,424 &el!(Expr::Apply(425 el!(Expr::Index(426 el!(Expr::Var("std".into())),427 el!(Expr::Str("manifestYamlDoc".into()))428 )),429 ArgsDesc(vec![430 Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),431 Arg(None, el!(Expr::Str(" ".repeat(padding).into())))432 ]),433 false434 )),435 )?436 .try_cast_str("to json")?)437 })438 }439}440441fn is_function_like(val: &Val) -> bool {442 matches!(val, Val::Func(_))443}444445446pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {447 Ok(match (val_a.unwrap_if_lazy()?, val_b.unwrap_if_lazy()?) {448 (Val::Bool(a), Val::Bool(b)) => a == b,449 (Val::Null, Val::Null) => true,450 (Val::Str(a), Val::Str(b)) => a == b,451 (Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,452 (Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(453 "primitiveEquals operates on primitive types, got array".into(),454 )),455 (Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(456 "primitiveEquals operates on primitive types, got object".into(),457 )),458 (a, b) if is_function_like(&a) && is_function_like(&b) => {459 throw!(RuntimeError("cannot test equality of functions".into()))460 }461 (_, _) => false,462 })463}464465466pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {467 let val_a = val_a.unwrap_if_lazy()?;468 let val_b = val_b.unwrap_if_lazy()?;469470 if val_a.value_type()? != val_b.value_type()? {471 return Ok(false);472 }473 match (val_a, val_b) {474 475 (Val::Arr(a), Val::Arr(b)) => {476 if a.len() != b.len() {477 return Ok(false);478 }479 for (a, b) in a.iter().zip(b.iter()) {480 if !equals(&a.unwrap_if_lazy()?, &b.unwrap_if_lazy()?)? {481 return Ok(false);482 }483 }484 Ok(true)485 }486 (Val::Obj(a), Val::Obj(b)) => {487 let fields = a.visible_fields();488 if fields != b.visible_fields() {489 return Ok(false);490 }491 for field in fields {492 if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {493 return Ok(false);494 }495 }496 Ok(true)497 }498 (a, b) => Ok(primitive_equals(&a, &b)?),499 }500}