difftreelog
feat(evaluator) add ToString manifest format
in: master
1 file changed
crates/jrsonnet-evaluator/src/val.rsdiffbeforeafterboth1use 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 String,205}206207#[derive(Debug, Clone)]208pub enum Val {209 Bool(bool),210 Null,211 Str(Rc<str>),212 Num(f64),213 Lazy(LazyVal),214 Arr(Rc<Vec<Val>>),215 Obj(ObjValue),216 Func(Rc<FuncVal>),217}218219macro_rules! matches_unwrap {220 ($e: expr, $p: pat, $r: expr) => {221 match $e {222 $p => $r,223 _ => panic!("no match"),224 }225 };226}227impl Val {228 /// Creates `Val::Num` after checking for numeric overflow.229 /// As numbers are `f64`, we can just check for their finity.230 pub fn new_checked_num(num: f64) -> Result<Self> {231 if num.is_finite() {232 Ok(Self::Num(num))233 } else {234 throw!(RuntimeError("overflow".into()))235 }236 }237238 pub fn assert_type(&self, context: &'static str, val_type: ValType) -> Result<()> {239 let this_type = self.value_type()?;240 if this_type != val_type {241 throw!(TypeMismatch(context, vec![val_type], this_type))242 } else {243 Ok(())244 }245 }246 pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {247 self.assert_type(context, ValType::Bool)?;248 Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Bool(v), v))249 }250 pub fn try_cast_str(self, context: &'static str) -> Result<Rc<str>> {251 self.assert_type(context, ValType::Str)?;252 Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Str(v), v))253 }254 pub fn try_cast_num(self, context: &'static str) -> Result<f64> {255 self.assert_type(context, ValType::Num)?;256 Ok(matches_unwrap!(self.unwrap_if_lazy()?, Self::Num(v), v))257 }258 pub fn inplace_unwrap(&mut self) -> Result<()> {259 while let Self::Lazy(lazy) = self {260 *self = lazy.evaluate()?;261 }262 Ok(())263 }264 pub fn unwrap_if_lazy(&self) -> Result<Self> {265 Ok(if let Self::Lazy(v) = self {266 v.evaluate()?.unwrap_if_lazy()?267 } else {268 self.clone()269 })270 }271 pub fn value_type(&self) -> Result<ValType> {272 Ok(match self {273 Self::Str(..) => ValType::Str,274 Self::Num(..) => ValType::Num,275 Self::Arr(..) => ValType::Arr,276 Self::Obj(..) => ValType::Obj,277 Self::Bool(_) => ValType::Bool,278 Self::Null => ValType::Null,279 Self::Func(..) => ValType::Func,280 Self::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,281 })282 }283284 pub fn to_string(&self) -> Result<Rc<str>> {285 Ok(match self.unwrap_if_lazy()? {286 Self::Bool(true) => "true".into(),287 Self::Bool(false) => "false".into(),288 Self::Null => "null".into(),289 Self::Str(s) => s,290 v => manifest_json_ex(291 &v,292 &ManifestJsonOptions {293 padding: "",294 mtype: ManifestType::ToString,295 },296 )?297 .into(),298 })299 }300301 /// Expects value to be object, outputs (key, manifested value) pairs302 pub fn manifest_multi(&self, ty: &ManifestFormat) -> Result<Vec<(Rc<str>, Rc<str>)>> {303 let obj = match self {304 Self::Obj(obj) => obj,305 _ => throw!(MultiManifestOutputIsNotAObject),306 };307 let keys = obj.visible_fields();308 let mut out = Vec::with_capacity(keys.len());309 for key in keys {310 let value = obj311 .get(key.clone())?312 .expect("item in object")313 .manifest(ty)?;314 out.push((key, value));315 }316 Ok(out)317 }318319 /// Expects value to be array, outputs manifested values320 pub fn manifest_stream(&self, ty: &ManifestFormat) -> Result<Vec<Rc<str>>> {321 let arr = match self {322 Self::Arr(a) => a,323 _ => throw!(StreamManifestOutputIsNotAArray),324 };325 let mut out = Vec::with_capacity(arr.len());326 for i in arr.iter() {327 out.push(i.manifest(ty)?);328 }329 Ok(out)330 }331332 pub fn manifest(&self, ty: &ManifestFormat) -> Result<Rc<str>> {333 Ok(match ty {334 ManifestFormat::YamlStream(format) => {335 let arr = match self {336 Self::Arr(a) => a,337 _ => throw!(StreamManifestOutputIsNotAArray),338 };339 let mut out = String::new();340341 match format as &ManifestFormat {342 ManifestFormat::YamlStream(_) => throw!(StreamManifestOutputCannotBeRecursed),343 ManifestFormat::String => throw!(StreamManifestCannotNestString),344 _ => {}345 };346347 if !arr.is_empty() {348 for v in arr.iter() {349 out.push_str("---\n");350 out.push_str(&v.manifest(format)?);351 out.push_str("\n");352 }353 out.push_str("...");354 }355356 out.into()357 }358 ManifestFormat::Yaml(padding) => self.to_yaml(*padding)?,359 ManifestFormat::Json(padding) => self.to_json(*padding)?,360 ManifestFormat::String => match self {361 Self::Str(s) => s.clone(),362 _ => throw!(StringManifestOutputIsNotAString),363 },364 })365 }366367 /// For manifestification368 pub fn to_json(&self, padding: usize) -> Result<Rc<str>> {369 manifest_json_ex(370 self,371 &ManifestJsonOptions {372 padding: &" ".repeat(padding),373 mtype: if padding == 0 {374 ManifestType::Minify375 } else {376 ManifestType::Manifest377 },378 },379 )380 .map(|s| s.into())381 }382383 /// Calls `std.manifestJson`384 #[cfg(feature = "faster")]385 pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {386 manifest_json_ex(387 self,388 &ManifestJsonOptions {389 padding: &" ".repeat(padding),390 mtype: ManifestType::Std,391 },392 )393 .map(|s| s.into())394 }395396 /// Calls `std.manifestJson`397 #[cfg(not(feature = "faster"))]398 pub fn to_std_json(&self, padding: usize) -> Result<Rc<str>> {399 with_state(|s| {400 let ctx = s401 .create_default_context()?402 .with_var("__tmp__to_json__".into(), self.clone())?;403 Ok(evaluate(404 ctx,405 &el!(Expr::Apply(406 el!(Expr::Index(407 el!(Expr::Var("std".into())),408 el!(Expr::Str("manifestJsonEx".into()))409 )),410 ArgsDesc(vec![411 Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),412 Arg(None, el!(Expr::Str(" ".repeat(padding).into())))413 ]),414 false415 )),416 )?417 .try_cast_str("to json")?)418 })419 }420 pub fn to_yaml(&self, padding: usize) -> Result<Rc<str>> {421 with_state(|s| {422 let ctx = s423 .create_default_context()?424 .with_var("__tmp__to_json__".into(), self.clone());425 Ok(evaluate(426 ctx,427 &el!(Expr::Apply(428 el!(Expr::Index(429 el!(Expr::Var("std".into())),430 el!(Expr::Str("manifestYamlDoc".into()))431 )),432 ArgsDesc(vec![433 Arg(None, el!(Expr::Var("__tmp__to_json__".into()))),434 Arg(435 None,436 el!(Expr::Literal(if padding != 0 {437 LiteralType::True438 } else {439 LiteralType::False440 }))441 )442 ]),443 false444 )),445 )?446 .try_cast_str("to json")?)447 })448 }449}450451const fn is_function_like(val: &Val) -> bool {452 matches!(val, Val::Func(_))453}454455/// Native implementation of `std.primitiveEquals`456pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {457 Ok(match (val_a.unwrap_if_lazy()?, val_b.unwrap_if_lazy()?) {458 (Val::Bool(a), Val::Bool(b)) => a == b,459 (Val::Null, Val::Null) => true,460 (Val::Str(a), Val::Str(b)) => a == b,461 (Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,462 (Val::Arr(_), Val::Arr(_)) => throw!(RuntimeError(463 "primitiveEquals operates on primitive types, got array".into(),464 )),465 (Val::Obj(_), Val::Obj(_)) => throw!(RuntimeError(466 "primitiveEquals operates on primitive types, got object".into(),467 )),468 (a, b) if is_function_like(&a) && is_function_like(&b) => {469 throw!(RuntimeError("cannot test equality of functions".into()))470 }471 (_, _) => false,472 })473}474475/// Native implementation of `std.equals`476pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {477 let val_a = val_a.unwrap_if_lazy()?;478 let val_b = val_b.unwrap_if_lazy()?;479480 if val_a.value_type()? != val_b.value_type()? {481 return Ok(false);482 }483 match (val_a, val_b) {484 // Cant test for ptr equality, because all fields needs to be evaluated485 (Val::Arr(a), Val::Arr(b)) => {486 if a.len() != b.len() {487 return Ok(false);488 }489 for (a, b) in a.iter().zip(b.iter()) {490 if !equals(&a.unwrap_if_lazy()?, &b.unwrap_if_lazy()?)? {491 return Ok(false);492 }493 }494 Ok(true)495 }496 (Val::Obj(a), Val::Obj(b)) => {497 let fields = a.visible_fields();498 if fields != b.visible_fields() {499 return Ok(false);500 }501 for field in fields {502 if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {503 return Ok(false);504 }505 }506 Ok(true)507 }508 (a, b) => Ok(primitive_equals(&a, &b)?),509 }510}