1use crate::{2 equals,3 error::{Error::*, Result},4 evaluate, parse_args, primitive_equals, push, throw, with_state, Context, FuncVal, Val,5 ValType,6};7use format::{format_arr, format_obj};8use jrsonnet_parser::{ArgsDesc, ExprLocation};9use manifest::{escape_string_json, manifest_json_ex, ManifestJsonOptions, ManifestType};10use std::{path::PathBuf, rc::Rc};1112pub mod stdlib;13pub use stdlib::*;1415pub mod format;16pub mod manifest;17pub mod sort;1819fn std_format(str: Rc<str>, vals: Val) -> Result<Val> {20 push(21 &Some(ExprLocation(Rc::from(PathBuf::from("std.jsonnet")), 0, 0)),22 || format!("std.format of {}", str),23 || {24 Ok(match vals {25 Val::Arr(vals) => Val::Str(format_arr(&str, &vals)?.into()),26 Val::Obj(obj) => Val::Str(format_obj(&str, &obj)?.into()),27 o => Val::Str(format_arr(&str, &[o])?.into()),28 })29 },30 )31}3233#[allow(clippy::cognitive_complexity)]34pub fn call_builtin(35 context: Context,36 loc: &Option<ExprLocation>,37 name: &str,38 args: &ArgsDesc,39) -> Result<Val> {40 Ok(match name as &str {41 42 "length" => parse_args!(context, "std.length", args, 1, [43 0, x: [Val::Str|Val::Arr|Val::Obj], vec![ValType::Str, ValType::Arr, ValType::Obj];44 ], {45 Ok(match x {46 Val::Str(n) => Val::Num(n.chars().count() as f64),47 Val::Arr(i) => Val::Num(i.len() as f64),48 Val::Obj(o) => Val::Num(49 o.fields_visibility()50 .into_iter()51 .filter(|(_k, v)| *v)52 .count() as f64,53 ),54 _ => unreachable!(),55 })56 })?,57 58 "type" => parse_args!(context, "std.type", args, 1, [59 0, x, vec![];60 ], {61 Ok(Val::Str(x.value_type()?.name().into()))62 })?,63 64 "makeArray" => parse_args!(context, "std.makeArray", args, 2, [65 0, sz: [Val::Num]!!Val::Num, vec![ValType::Num];66 1, func: [Val::Func]!!Val::Func, vec![ValType::Func];67 ], {68 if sz < 0.0 {69 throw!(RuntimeError(format!("makeArray requires size >= 0, got {}", sz).into()));70 }71 let mut out = Vec::with_capacity(sz as usize);72 for i in 0..sz as usize {73 out.push(func.evaluate_values(74 Context::new(),75 &[Val::Num(i as f64)]76 )?)77 }78 Ok(Val::Arr(Rc::new(out)))79 })?,80 81 "codepoint" => parse_args!(context, "std.codepoint", args, 1, [82 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];83 ], {84 assert!(85 str.chars().count() == 1,86 "std.codepoint should receive single char string"87 );88 Ok(Val::Num(str.chars().take(1).next().unwrap() as u32 as f64))89 })?,90 91 "objectFieldsEx" => parse_args!(context, "std.objectFieldsEx",args, 2, [92 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];93 1, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];94 ], {95 let mut out = obj.fields_visibility()96 .into_iter()97 .filter(|(_k, v)| *v || inc_hidden)98 .map(|(k, _v)|k)99 .collect::<Vec<_>>();100 out.sort();101 Ok(Val::Arr(Rc::new(out.into_iter().map(Val::Str).collect())))102 })?,103 104 "objectHasEx" => parse_args!(context, "std.objectHasEx", args, 3, [105 0, obj: [Val::Obj]!!Val::Obj, vec![ValType::Obj];106 1, f: [Val::Str]!!Val::Str, vec![ValType::Str];107 2, inc_hidden: [Val::Bool]!!Val::Bool, vec![ValType::Bool];108 ], {109 Ok(Val::Bool(110 obj.fields_visibility()111 .into_iter()112 .filter(|(_k, v)| *v || inc_hidden)113 .any(|(k, _v)| *k == *f),114 ))115 })?,116117 118 "slice" => parse_args!(context, "slice", args, 4, [119 0, indexable: [Val::Str | Val::Arr], vec![ValType::Str, ValType::Arr];120 1, index, vec![ValType::Num, ValType::Null];121 2, end, vec![ValType::Num, ValType::Null];122 3, step, vec![ValType::Num, ValType::Null];123 ], {124 let index = match index {125 Val::Num(v) => v as usize,126 Val::Null => 0,127 _ => unreachable!(),128 };129 let end = match end {130 Val::Num(v) => v as usize,131 Val::Null => match &indexable {132 Val::Str(s) => s.chars().count(),133 Val::Arr(v) => v.len(),134 _ => unreachable!()135 },136 _ => unreachable!()137 };138 let step = match step {139 Val::Num(v) => v as usize,140 Val::Null => 1,141 _ => unreachable!()142 };143 match &indexable {144 Val::Str(s) => {145 Ok(Val::Str((s.chars().skip(index).take(end-index).step_by(step).collect::<String>()).into()))146 }147 Val::Arr(arr) => {148 Ok(Val::Arr((arr.iter().skip(index).take(end-index).step_by(step).cloned().collect::<Vec<Val>>()).into()))149 }150 _ => unreachable!()151 }152 })?,153 "primitiveEquals" => parse_args!(context, "std.primitiveEquals", args, 2, [154 0, a, vec![];155 1, b, vec![];156 ], {157 Ok(Val::Bool(primitive_equals(&a, &b)?))158 })?,159 160 "equals" => parse_args!(context, "std.equals", args, 2, [161 0, a, vec![];162 1, b, vec![];163 ], {164 Ok(Val::Bool(equals(&a, &b)?))165 })?,166 "mod" => parse_args!(context, "std.mod", args, 2, [167 0, a: [Val::Num | Val::Str], vec![ValType::Num, ValType::Str];168 1, b, vec![];169 ], {170 match (a, b) {171 (Val::Num(a), Val::Num(b)) => Ok(Val::Num(a % b)),172 (Val::Str(str), vals) => std_format(str, vals),173 (a, b) => throw!(BinaryOperatorDoesNotOperateOnValues(jrsonnet_parser::BinaryOpType::Mod, a.value_type()?, b.value_type()?))174 }175 })?,176 "modulo" => parse_args!(context, "std.modulo", args, 2, [177 0, a: [Val::Num]!!Val::Num, vec![ValType::Num];178 1, b: [Val::Num]!!Val::Num, vec![ValType::Num];179 ], {180 Ok(Val::Num(a % b))181 })?,182 "floor" => parse_args!(context, "std.floor", args, 1, [183 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];184 ], {185 Ok(Val::Num(x.floor()))186 })?,187 "log" => parse_args!(context, "std.log", args, 2, [188 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];189 ], {190 Ok(Val::Num(n.ln()))191 })?,192 "trace" => parse_args!(context, "std.trace", args, 2, [193 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];194 1, rest, vec![];195 ], {196 eprint!("TRACE:");197 if let Some(loc) = loc {198 with_state(|s|{199 let locs = s.map_source_locations(&loc.0, &[loc.1]);200 eprint!(" {}:{}", loc.0.file_name().unwrap().to_str().unwrap(), locs[0].line);201 });202 }203 eprintln!(" {}", str);204 Ok(rest)205 })?,206 "pow" => parse_args!(context, "std.modulo", args, 2, [207 0, x: [Val::Num]!!Val::Num, vec![ValType::Num];208 1, n: [Val::Num]!!Val::Num, vec![ValType::Num];209 ], {210 Ok(Val::Num(x.powf(n)))211 })?,212 "extVar" => parse_args!(context, "std.extVar", args, 1, [213 0, x: [Val::Str]!!Val::Str, vec![ValType::Str];214 ], {215 Ok(with_state(|s| s.settings().ext_vars.get(&x).cloned()).ok_or(UndefinedExternalVariable(x))?)216 })?,217 "native" => parse_args!(context, "std.native", args, 1, [218 0, x: [Val::Str]!!Val::Str, vec![ValType::Str];219 ], {220 Ok(with_state(|s| s.settings().ext_natives.get(&x).cloned()).map(|v| Val::Func(Rc::new(FuncVal::NativeExt(x.clone(), v)))).ok_or(UndefinedExternalFunction(x))?)221 })?,222 "filter" => parse_args!(context, "std.filter", args, 2, [223 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];224 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];225 ], {226 Ok(Val::Arr(Rc::new(227 arr.iter()228 .cloned()229 .filter(|e| {230 func231 .evaluate_values(context.clone(), &[e.clone()])232 .unwrap()233 .try_cast_bool("filter predicate")234 .unwrap()235 })236 .collect(),237 )))238 })?,239 240 "foldl" => parse_args!(context, "std.foldl", args, 3, [241 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];242 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];243 2, init, vec![];244 ], {245 let mut acc = init;246 for i in arr.iter().cloned() {247 acc = func.evaluate_values(context.clone(), &[acc, i])?;248 }249 Ok(acc)250 })?,251 252 "foldr" => parse_args!(context, "std.foldr", args, 3, [253 0, func: [Val::Func]!!Val::Func, vec![ValType::Func];254 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];255 2, init, vec![];256 ], {257 let mut acc = init;258 for i in arr.iter().rev().cloned() {259 acc = func.evaluate_values(context.clone(), &[acc, i])?;260 }261 Ok(acc)262 })?,263 264 #[allow(non_snake_case)]265 "sortImpl" => parse_args!(context, "std.sort", args, 2, [266 0, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];267 1, keyF: [Val::Func]!!Val::Func, vec![ValType::Func];268 ], {269 if arr.len() <= 1 {270 return Ok(Val::Arr(arr))271 }272 Ok(Val::Arr(sort::sort(context, arr, &keyF)?))273 })?,274 275 "format" => parse_args!(context, "std.format", args, 2, [276 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];277 1, vals, vec![]278 ], {279 std_format(str, vals)280 })?,281 282 "range" => parse_args!(context, "std.range", args, 2, [283 0, from: [Val::Num]!!Val::Num, vec![ValType::Num];284 1, to: [Val::Num]!!Val::Num, vec![ValType::Num];285 ], {286 if to < from {287 return Ok(Val::Arr(Rc::new(Vec::new())))288 }289 let mut out = Vec::with_capacity((1+to as usize-from as usize).max(0));290 for i in from as usize..=to as usize {291 out.push(Val::Num(i as f64));292 }293 Ok(Val::Arr(Rc::new(out)))294 })?,295 "char" => parse_args!(context, "std.char", args, 1, [296 0, n: [Val::Num]!!Val::Num, vec![ValType::Num];297 ], {298 let mut out = String::new();299 out.push(std::char::from_u32(n as u32).ok_or_else(||300 InvalidUnicodeCodepointGot(n as u32)301 )?);302 Ok(Val::Str(out.into()))303 })?,304 "encodeUTF8" => parse_args!(context, "std.encodeUtf8", args, 1, [305 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];306 ], {307 Ok(Val::Arr(Rc::new(str.bytes().map(|b| Val::Num(b as f64)).collect())))308 })?,309 "md5" => parse_args!(context, "std.md5", args, 1, [310 0, str: [Val::Str]!!Val::Str, vec![ValType::Str];311 ], {312 Ok(Val::Str(format!("{:x}", md5::compute(&str.as_bytes())).into()))313 })?,314 315 "base64" => parse_args!(context, "std.base64", args, 1, [316 0, input: [Val::Str | Val::Arr], vec![ValType::Arr, ValType::Str];317 ], {318 Ok(Val::Str(match input {319 Val::Str(s) => {320 base64::encode(s.bytes().collect::<Vec<_>>()).into()321 },322 Val::Arr(a) => {323 base64::encode(a.iter().map(|v| {324 Ok(v.clone().try_cast_num("base64 array")? as u8)325 }).collect::<Result<Vec<_>>>()?).into()326 },327 _ => unreachable!()328 }))329 })?,330 331 "join" => parse_args!(context, "std.join", args, 2, [332 0, sep: [Val::Str|Val::Arr], vec![ValType::Str, ValType::Arr];333 1, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];334 ], {335 Ok(match sep {336 Val::Arr(joiner_items) => {337 let mut out = Vec::new();338339 let mut first = true;340 for item in arr.iter().cloned() {341 if let Val::Arr(items) = item.unwrap_if_lazy()? {342 if !first {343 out.reserve(joiner_items.len());344 out.extend(joiner_items.iter().cloned());345 }346 first = false;347 out.reserve(items.len());348 out.extend(items.iter().cloned());349 } else {350 throw!(RuntimeError("in std.join all items should be arrays".into()));351 }352 }353354 Val::Arr(Rc::new(out))355 },356 Val::Str(sep) => {357 let mut out = String::new();358359 let mut first = true;360 for item in arr.iter().cloned() {361 if let Val::Str(item) = item.unwrap_if_lazy()? {362 if !first {363 out += &sep;364 }365 first = false;366 out += &item;367 } else {368 throw!(RuntimeError("in std.join all items should be strings".into()));369 }370 }371372 Val::Str(out.into())373 },374 _ => unreachable!()375 })376 })?,377 378 "escapeStringJson" => parse_args!(context, "std.escapeStringJson", args, 1, [379 0, str_: [Val::Str]!!Val::Str, vec![ValType::Str];380 ], {381 Ok(Val::Str(escape_string_json(&str_).into()))382 })?,383 384 "manifestJsonEx" => parse_args!(context, "std.manifestJsonEx", args, 2, [385 0, value, vec![];386 1, indent: [Val::Str]!!Val::Str, vec![ValType::Str];387 ], {388 Ok(Val::Str(manifest_json_ex(&value, &ManifestJsonOptions {389 padding: &indent,390 mtype: ManifestType::Std,391 })?.into()))392 })?,393 394 "reverse" => parse_args!(context, "std.reverse", args, 1, [395 0, arr: [Val::Arr]!!Val::Arr, vec![ValType::Arr];396 ], {397 let mut marr = arr;398 Rc::make_mut(&mut marr).reverse();399 Ok(Val::Arr(marr))400 })?,401 "id" => parse_args!(context, "std.id", args, 1, [402 0, v, vec![];403 ], {404 Ok(v)405 })?,406 name => throw!(IntrinsicNotFound(name.into())),407 })408}