1use crate::typed::{Any, Either, Null, PositiveF64, VecVal, M1};2use crate::{self as jrsonnet_evaluator, ObjValue};3use crate::{4 builtin::manifest::{manifest_yaml_ex, ManifestYamlOptions},5 equals,6 error::{Error::*, Result},7 operator::evaluate_mod_op,8 primitive_equals, push_frame, throw, with_state, ArrValue, Context, FuncVal,9 IndexableVal, Val,10};11use format::{format_arr, format_obj};12use gcmodule::Cc;13use jrsonnet_interner::IStr;14use jrsonnet_parser::{ArgsDesc, ExprLocation};15use serde::Deserialize;16use serde_yaml::DeserializingQuirks;17use std::{18 collections::HashMap,19 convert::{TryFrom, TryInto},20 path::PathBuf,21 rc::Rc,22};2324pub mod stdlib;25pub use stdlib::*;2627use self::manifest::{escape_string_json, manifest_json_ex, ManifestJsonOptions, ManifestType};2829pub mod format;30pub mod manifest;31pub mod sort;3233pub fn std_format(str: IStr, vals: Val) -> Result<String> {34 push_frame(35 &ExprLocation(Rc::from(PathBuf::from("std.jsonnet")), 0, 0),36 || format!("std.format of {}", str),37 || {38 Ok(match vals {39 Val::Arr(vals) => format_arr(&str, &vals.evaluated()?)?,40 Val::Obj(obj) => format_obj(&str, &obj)?,41 o => format_arr(&str, &[o])?,42 })43 },44 )45}4647pub fn std_slice(48 indexable: IndexableVal,49 index: Option<usize>,50 end: Option<usize>,51 step: Option<usize>,52) -> Result<Val> {53 let index = index.unwrap_or(0);54 let end = end.unwrap_or_else(|| match &indexable {55 IndexableVal::Str(_) => usize::MAX,56 IndexableVal::Arr(v) => v.len(),57 });58 let step = step.unwrap_or(1);59 match &indexable {60 IndexableVal::Str(s) => Ok(Val::Str(61 (s.chars()62 .skip(index)63 .take(end - index)64 .step_by(step)65 .collect::<String>())66 .into(),67 )),68 IndexableVal::Arr(arr) => Ok(Val::Arr(69 (arr.iter()70 .skip(index)71 .take(end - index)72 .step_by(step)73 .collect::<Result<Vec<Val>>>()?)74 .into(),75 )),76 }77}7879type Builtin = fn(context: Context, loc: &ExprLocation, args: &ArgsDesc) -> Result<Val>;8081type BuiltinsType = HashMap<Box<str>, Builtin>;8283thread_local! {84 static BUILTINS: BuiltinsType = {85 [86 ("length".into(), builtin_length as Builtin),87 ("type".into(), builtin_type),88 ("makeArray".into(), builtin_make_array),89 ("codepoint".into(), builtin_codepoint),90 ("objectFieldsEx".into(), builtin_object_fields_ex),91 ("objectHasEx".into(), builtin_object_has_ex),92 ("slice".into(), builtin_slice),93 ("substr".into(), builtin_substr),94 ("primitiveEquals".into(), builtin_primitive_equals),95 ("equals".into(), builtin_equals),96 ("modulo".into(), builtin_modulo),97 ("mod".into(), builtin_mod),98 ("floor".into(), builtin_floor),99 ("ceil".into(), builtin_ceil),100 ("log".into(), builtin_log),101 ("pow".into(), builtin_pow),102 ("sqrt".into(), builtin_sqrt),103 ("sin".into(), builtin_sin),104 ("cos".into(), builtin_cos),105 ("tan".into(), builtin_tan),106 ("asin".into(), builtin_asin),107 ("acos".into(), builtin_acos),108 ("atan".into(), builtin_atan),109 ("exp".into(), builtin_exp),110 ("mantissa".into(), builtin_mantissa),111 ("exponent".into(), builtin_exponent),112 ("extVar".into(), builtin_ext_var),113 ("native".into(), builtin_native),114 ("filter".into(), builtin_filter),115 ("map".into(), builtin_map),116 ("flatMap".into(), builtin_flatmap),117 ("foldl".into(), builtin_foldl),118 ("foldr".into(), builtin_foldr),119 ("sortImpl".into(), builtin_sort_impl),120 ("format".into(), builtin_format),121 ("range".into(), builtin_range),122 ("char".into(), builtin_char),123 ("encodeUTF8".into(), builtin_encode_utf8),124 ("decodeUTF8".into(), builtin_decode_utf8),125 ("md5".into(), builtin_md5),126 ("base64".into(), builtin_base64),127 ("base64DecodeBytes".into(), builtin_base64_decode_bytes),128 ("base64Decode".into(), builtin_base64_decode),129 ("trace".into(), builtin_trace),130 ("join".into(), builtin_join),131 ("escapeStringJson".into(), builtin_escape_string_json),132 ("manifestJsonEx".into(), builtin_manifest_json_ex),133 ("manifestYamlDocImpl".into(), builtin_manifest_yaml_doc),134 ("reverse".into(), builtin_reverse),135 ("id".into(), builtin_id),136 ("strReplace".into(), builtin_str_replace),137 ("splitLimit".into(), builtin_splitlimit),138 ("parseJson".into(), builtin_parse_json),139 ("parseYaml".into(), builtin_parse_yaml),140 ("asciiUpper".into(), builtin_ascii_upper),141 ("asciiLower".into(), builtin_ascii_lower),142 ("member".into(), builtin_member),143 ("count".into(), builtin_count),144 ].iter().cloned().collect()145 };146}147148#[jrsonnet_macros::builtin]149fn builtin_length(x: Either<IStr, Either<VecVal, ObjValue>>) -> Result<usize> {150 Ok(match x {151 Either::Left(x) => x.len(),152 Either::Right(Either::Left(x)) => x.0.len(),153 Either::Right(Either::Right(x)) => x154 .fields_visibility()155 .into_iter()156 .filter(|(_k, v)| *v)157 .count(),158 })159}160161#[jrsonnet_macros::builtin]162fn builtin_type(x: Any) -> Result<IStr> {163 Ok(x.0.value_type().name().into())164}165166#[jrsonnet_macros::builtin]167fn builtin_make_array(sz: usize, func: Cc<FuncVal>) -> Result<VecVal> {168 let mut out = Vec::with_capacity(sz);169 for i in 0..sz {170 out.push(func.evaluate_values(&[Val::Num(i as f64)])?)171 }172 Ok(VecVal(out))173}174175#[jrsonnet_macros::builtin]176const fn builtin_codepoint(str: char) -> Result<u32> {177 Ok(str as u32)178}179180#[jrsonnet_macros::builtin]181fn builtin_object_fields_ex(obj: ObjValue, inc_hidden: bool) -> Result<VecVal> {182 let out = obj.fields_ex(inc_hidden);183 Ok(VecVal(out.into_iter().map(Val::Str).collect::<Vec<_>>()))184}185186#[jrsonnet_macros::builtin]187fn builtin_object_has_ex(obj: ObjValue, f: IStr, inc_hidden: bool) -> Result<bool> {188 Ok(obj.has_field_ex(f, inc_hidden))189}190191#[jrsonnet_macros::builtin]192fn builtin_parse_json(s: IStr) -> Result<Any> {193 let value: serde_json::Value = serde_json::from_str(&s)194 .map_err(|e| RuntimeError(format!("failed to parse json: {}", e).into()))?;195 Ok(Any(Val::try_from(&value)?))196}197198#[jrsonnet_macros::builtin]199fn builtin_parse_yaml(s: IStr) -> Result<Any> {200 let value = serde_yaml::Deserializer::from_str_with_quirks(201 &s,202 DeserializingQuirks { old_octals: true },203 );204 let mut out = vec![];205 for item in value {206 let value = serde_json::Value::deserialize(item)207 .map_err(|e| RuntimeError(format!("failed to parse yaml: {}", e).into()))?;208 let val = Val::try_from(&value)?;209 out.push(val);210 }211 Ok(Any(if out.is_empty() {212 Val::Null213 } else if out.len() == 1 {214 out.into_iter().next().unwrap()215 } else {216 Val::Arr(out.into())217 }))218}219220#[jrsonnet_macros::builtin]221fn builtin_slice(222 indexable: IndexableVal,223 index: Either<usize, Null>,224 end: Either<usize, Null>,225 step: Either<usize, Null>,226) -> Result<Any> {227 std_slice(indexable, index.left(), end.left(), step.left()).map(Any)228}229230#[jrsonnet_macros::builtin]231fn builtin_substr(str: IStr, from: usize, len: usize) -> Result<String> {232 Ok(str.chars().skip(from as usize).take(len as usize).collect())233}234235#[jrsonnet_macros::builtin]236fn builtin_primitive_equals(a: Any, b: Any) -> Result<bool> {237 primitive_equals(&a.0, &b.0)238}239240#[jrsonnet_macros::builtin]241fn builtin_equals(a: Any, b: Any) -> Result<bool> {242 equals(&a.0, &b.0)243}244245#[jrsonnet_macros::builtin]246fn builtin_modulo(a: f64, b: f64) -> Result<f64> {247 Ok(a % b)248}249250#[jrsonnet_macros::builtin]251fn builtin_mod(a: Either<f64, IStr>, b: Any) -> Result<Any> {252 Ok(Any(evaluate_mod_op(253 &match a {254 Either::Left(v) => Val::Num(v),255 Either::Right(s) => Val::Str(s),256 },257 &b.0,258 )?))259}260261#[jrsonnet_macros::builtin]262fn builtin_floor(x: f64) -> Result<f64> {263 Ok(x.floor())264}265266#[jrsonnet_macros::builtin]267fn builtin_ceil(x: f64) -> Result<f64> {268 Ok(x.ceil())269}270271#[jrsonnet_macros::builtin]272fn builtin_log(n: f64) -> Result<f64> {273 Ok(n.ln())274}275276#[jrsonnet_macros::builtin]277fn builtin_pow(x: f64, n: f64) -> Result<f64> {278 Ok(x.powf(n))279}280281#[jrsonnet_macros::builtin]282fn builtin_sqrt(x: PositiveF64) -> Result<f64> {283 Ok(x.0.sqrt())284}285286#[jrsonnet_macros::builtin]287fn builtin_sin(x: f64) -> Result<f64> {288 Ok(x.sin())289}290291#[jrsonnet_macros::builtin]292fn builtin_cos(x: f64) -> Result<f64> {293 Ok(x.cos())294}295296#[jrsonnet_macros::builtin]297fn builtin_tan(x: f64) -> Result<f64> {298 Ok(x.tan())299}300301#[jrsonnet_macros::builtin]302fn builtin_asin(x: f64) -> Result<f64> {303 Ok(x.asin())304}305306#[jrsonnet_macros::builtin]307fn builtin_acos(x: f64) -> Result<f64> {308 Ok(x.acos())309}310311#[jrsonnet_macros::builtin]312fn builtin_atan(x: f64) -> Result<f64> {313 Ok(x.atan())314}315316#[jrsonnet_macros::builtin]317fn builtin_exp(x: f64) -> Result<f64> {318 Ok(x.exp())319}320321fn frexp(s: f64) -> (f64, i16) {322 if 0.0 == s {323 (s, 0)324 } else {325 let lg = s.abs().log2();326 let x = (lg - lg.floor() - 1.0).exp2();327 let exp = lg.floor() + 1.0;328 (s.signum() * x, exp as i16)329 }330}331332#[jrsonnet_macros::builtin]333fn builtin_mantissa(x: f64) -> Result<f64> {334 Ok(frexp(x).0)335}336337#[jrsonnet_macros::builtin]338fn builtin_exponent(x: f64) -> Result<i16> {339 Ok(frexp(x).1)340}341342#[jrsonnet_macros::builtin]343fn builtin_ext_var(x: IStr) -> Result<Any> {344 Ok(Any(with_state(|s| s.settings().ext_vars.get(&x).cloned())345 .ok_or(UndefinedExternalVariable(x))?))346}347348#[jrsonnet_macros::builtin]349fn builtin_native(name: IStr) -> Result<Cc<FuncVal>> {350 Ok(with_state(|s| s.settings().ext_natives.get(&name).cloned())351 .map(|v| Cc::new(FuncVal::NativeExt(name.clone(), v)))352 .ok_or(UndefinedExternalFunction(name))?)353}354355#[jrsonnet_macros::builtin]356fn builtin_filter(func: Cc<FuncVal>, arr: ArrValue) -> Result<ArrValue> {357 arr.filter(|val| bool::try_from(func.evaluate_values(&[val.clone()])?))358}359360#[jrsonnet_macros::builtin]361fn builtin_map(func: Cc<FuncVal>, arr: ArrValue) -> Result<ArrValue> {362 arr.map(|val| func.evaluate_values(&[val]))363}364365#[jrsonnet_macros::builtin]366fn builtin_flatmap(func: Cc<FuncVal>, arr: IndexableVal) -> Result<IndexableVal> {367 match arr {368 IndexableVal::Str(s) => {369 let mut out = String::new();370 for c in s.chars() {371 match func.evaluate_values(&[Val::Str(c.to_string().into())])? {372 Val::Str(o) => out.push_str(&o),373 _ => throw!(RuntimeError(374 "in std.join all items should be strings".into()375 )),376 };377 }378 Ok(IndexableVal::Str(out.into()))379 }380 IndexableVal::Arr(a) => {381 let mut out = Vec::new();382 for el in a.iter() {383 let el = el?;384 match func.evaluate_values(&[el])? {385 Val::Arr(o) => {386 for oe in o.iter() {387 out.push(oe?)388 }389 }390 _ => throw!(RuntimeError(391 "in std.join all items should be arrays".into()392 )),393 };394 }395 Ok(IndexableVal::Arr(out.into()))396 }397 }398}399400#[jrsonnet_macros::builtin]401fn builtin_foldl(func: Cc<FuncVal>, arr: ArrValue, init: Any) -> Result<Any> {402 let mut acc = init.0;403 for i in arr.iter() {404 acc = func.evaluate_values(&[acc, i?])?;405 }406 Ok(Any(acc))407}408409#[jrsonnet_macros::builtin]410fn builtin_foldr(func: Cc<FuncVal>, arr: ArrValue, init: Any) -> Result<Any> {411 let mut acc = init.0;412 for i in arr.iter().rev() {413 acc = func.evaluate_values(&[i?, acc])?;414 }415 Ok(Any(acc))416}417418#[jrsonnet_macros::builtin]419#[allow(non_snake_case)]420fn builtin_sort_impl(arr: ArrValue, keyF: Cc<FuncVal>) -> Result<ArrValue> {421 if arr.len() <= 1 {422 return Ok(arr);423 }424 Ok(ArrValue::Eager(sort::sort(arr.evaluated()?, &keyF)?))425}426427#[jrsonnet_macros::builtin]428fn builtin_format(str: IStr, vals: Any) -> Result<String> {429 std_format(str, vals.0)430}431432#[jrsonnet_macros::builtin]433fn builtin_range(from: i32, to: i32) -> Result<VecVal> {434 if to < from {435 return Ok(VecVal(Vec::new()));436 }437 let mut out = Vec::with_capacity((1 + to as usize - from as usize).max(0));438 for i in from as usize..=to as usize {439 out.push(Val::Num(i as f64));440 }441 Ok(VecVal(out))442}443444#[jrsonnet_macros::builtin]445fn builtin_char(n: u32) -> Result<char> {446 Ok(std::char::from_u32(n as u32).ok_or_else(|| InvalidUnicodeCodepointGot(n as u32))?)447}448449#[jrsonnet_macros::builtin]450fn builtin_encode_utf8(str: IStr) -> Result<VecVal> {451 Ok(VecVal(452 str.bytes()453 .map(|b| Val::Num(b as f64))454 .collect::<Vec<Val>>(),455 ))456}457458#[jrsonnet_macros::builtin]459fn builtin_decode_utf8(arr: Vec<u8>) -> Result<String> {460 Ok(String::from_utf8(arr).map_err(|_| RuntimeError("bad utf8".into()))?)461}462463#[jrsonnet_macros::builtin]464fn builtin_md5(str: IStr) -> Result<String> {465 Ok(format!("{:x}", md5::compute(&str.as_bytes())))466}467468#[jrsonnet_macros::builtin]469fn builtin_trace(#[location] loc: &ExprLocation, str: IStr, rest: Any) -> Result<Any> {470 eprint!("TRACE:");471 with_state(|s| {472 let locs = s.map_source_locations(&loc.0, &[loc.1]);473 eprint!(474 " {}:{}",475 loc.0.file_name().unwrap().to_str().unwrap(),476 locs[0].line477 );478 });479 eprintln!(" {}", str);480 Ok(rest) as Result<Any>481}482483#[jrsonnet_macros::builtin]484fn builtin_base64(input: Either<Vec<u8>, IStr>) -> Result<String> {485 Ok(match input {486 Either::Left(a) => base64::encode(a),487 Either::Right(l) => base64::encode(l.bytes().collect::<Vec<_>>()),488 })489}490491#[jrsonnet_macros::builtin]492fn builtin_base64_decode_bytes(input: IStr) -> Result<Vec<u8>> {493 Ok(base64::decode(&input.as_bytes()).map_err(|_| RuntimeError("bad base64".into()))?)494}495496#[jrsonnet_macros::builtin]497fn builtin_base64_decode(input: IStr) -> Result<String> {498 let bytes = base64::decode(&input.as_bytes()).map_err(|_| RuntimeError("bad base64".into()))?;499 Ok(String::from_utf8(bytes).map_err(|_| RuntimeError("bad utf8".into()))?)500}501502#[jrsonnet_macros::builtin]503fn builtin_join(sep: IndexableVal, arr: ArrValue) -> Result<IndexableVal> {504 Ok(match sep {505 IndexableVal::Arr(joiner_items) => {506 let mut out = Vec::new();507508 let mut first = true;509 for item in arr.iter() {510 let item = item?.clone();511 if let Val::Arr(items) = item {512 if !first {513 out.reserve(joiner_items.len());514 515 for item in joiner_items.iter() {516 out.push(item?);517 }518 }519 first = false;520 out.reserve(items.len());521 522 for item in items.iter() {523 out.push(item?);524 }525 } else {526 throw!(RuntimeError(527 "in std.join all items should be arrays".into()528 ));529 }530 }531532 IndexableVal::Arr(out.into())533 }534 IndexableVal::Str(sep) => {535 let mut out = String::new();536537 let mut first = true;538 for item in arr.iter() {539 let item = item?.clone();540 if let Val::Str(item) = item {541 if !first {542 out += &sep;543 }544 first = false;545 out += &item;546 } else {547 throw!(RuntimeError(548 "in std.join all items should be strings".into()549 ));550 }551 }552553 IndexableVal::Str(out.into())554 }555 })556}557558#[jrsonnet_macros::builtin]559fn builtin_escape_string_json(str_: IStr) -> Result<String> {560 Ok(escape_string_json(&str_))561}562563#[jrsonnet_macros::builtin]564fn builtin_manifest_json_ex(value: Any, indent: IStr) -> Result<String> {565 manifest_json_ex(566 &value.0,567 &ManifestJsonOptions {568 padding: &indent,569 mtype: ManifestType::Std,570 },571 )572}573574#[jrsonnet_macros::builtin]575fn builtin_manifest_yaml_doc(576 value: Any,577 indent_array_in_object: bool,578 quote_keys: bool,579) -> Result<String> {580 manifest_yaml_ex(581 &value.0,582 &ManifestYamlOptions {583 padding: " ",584 arr_element_padding: if indent_array_in_object { " " } else { "" },585 quote_keys,586 },587 )588}589590#[jrsonnet_macros::builtin]591fn builtin_reverse(value: ArrValue) -> Result<ArrValue> {592 Ok(value.reversed())593}594595#[jrsonnet_macros::builtin]596const fn builtin_id(v: Any) -> Result<Any> {597 Ok(v)598}599600#[jrsonnet_macros::builtin]601fn builtin_str_replace(str: String, from: IStr, to: IStr) -> Result<String> {602 Ok(str.replace(&from as &str, &to as &str))603}604605#[jrsonnet_macros::builtin]606fn builtin_splitlimit(str: IStr, c: char, maxsplits: Either<usize, M1>) -> Result<VecVal> {607 Ok(VecVal(match maxsplits {608 Either::Left(n) => str.splitn(n + 1, c).map(|s| Val::Str(s.into())).collect(),609 Either::Right(_) => str.split(c).map(|s| Val::Str(s.into())).collect(),610 }))611}612613#[jrsonnet_macros::builtin]614fn builtin_ascii_upper(str: IStr) -> Result<String> {615 Ok(str.to_ascii_uppercase())616}617618#[jrsonnet_macros::builtin]619fn builtin_ascii_lower(str: IStr) -> Result<String> {620 Ok(str.to_ascii_lowercase())621}622623#[jrsonnet_macros::builtin]624fn builtin_member(arr: IndexableVal, x: Any) -> Result<bool> {625 match arr {626 IndexableVal::Str(s) => {627 let x: IStr = IStr::try_from(x.0)?;628 Ok(!x.is_empty() && s.contains(&*x))629 }630 IndexableVal::Arr(a) => {631 for item in a.iter() {632 let item = item?;633 if equals(&item, &x.0)? {634 return Ok(true);635 }636 }637 Ok(false)638 }639 }640}641642#[jrsonnet_macros::builtin]643fn builtin_count(arr: Vec<Any>, v: Any) -> Result<usize> {644 let mut count = 0;645 for item in arr.iter() {646 if equals(&item.0, &v.0)? {647 count += 1;648 }649 }650 Ok(count)651}652653pub fn call_builtin(654 context: Context,655 loc: &ExprLocation,656 name: &str,657 args: &ArgsDesc,658) -> Result<Val> {659 BUILTINS660 .with(|builtins| builtins.get(name).copied())661 .ok_or_else(|| IntrinsicNotFound(name.into()))?(context, loc, args)662}