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 parse_args, 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 jrsonnet_types::ty;16use serde::Deserialize;17use serde_yaml::DeserializingQuirks;18use std::{19 collections::HashMap,20 convert::{TryFrom, TryInto},21 path::PathBuf,22 rc::Rc,23};2425pub mod stdlib;26pub use stdlib::*;2728use self::manifest::{escape_string_json, manifest_json_ex, ManifestJsonOptions, ManifestType};2930pub mod format;31pub mod manifest;32pub mod sort;3334pub fn std_format(str: IStr, vals: Val) -> Result<String> {35 push_frame(36 &ExprLocation(Rc::from(PathBuf::from("std.jsonnet")), 0, 0),37 || format!("std.format of {}", str),38 || {39 Ok(match vals {40 Val::Arr(vals) => format_arr(&str, &vals.evaluated()?)?,41 Val::Obj(obj) => format_obj(&str, &obj)?,42 o => format_arr(&str, &[o])?,43 })44 },45 )46}4748pub fn std_slice(49 indexable: IndexableVal,50 index: Option<usize>,51 end: Option<usize>,52 step: Option<usize>,53) -> Result<Val> {54 let index = index.unwrap_or(0);55 let end = end.unwrap_or_else(|| match &indexable {56 IndexableVal::Str(_) => usize::MAX,57 IndexableVal::Arr(v) => v.len(),58 });59 let step = step.unwrap_or(1);60 match &indexable {61 IndexableVal::Str(s) => Ok(Val::Str(62 (s.chars()63 .skip(index)64 .take(end - index)65 .step_by(step)66 .collect::<String>())67 .into(),68 )),69 IndexableVal::Arr(arr) => Ok(Val::Arr(70 (arr.iter()71 .skip(index)72 .take(end - index)73 .step_by(step)74 .collect::<Result<Vec<Val>>>()?)75 .into(),76 )),77 }78}7980type Builtin = fn(context: Context, loc: &ExprLocation, args: &ArgsDesc) -> Result<Val>;8182type BuiltinsType = HashMap<Box<str>, Builtin>;8384thread_local! {85 static BUILTINS: BuiltinsType = {86 [87 ("length".into(), builtin_length as Builtin),88 ("type".into(), builtin_type),89 ("makeArray".into(), builtin_make_array),90 ("codepoint".into(), builtin_codepoint),91 ("objectFieldsEx".into(), builtin_object_fields_ex),92 ("objectHasEx".into(), builtin_object_has_ex),93 ("slice".into(), builtin_slice),94 ("substr".into(), builtin_substr),95 ("primitiveEquals".into(), builtin_primitive_equals),96 ("equals".into(), builtin_equals),97 ("modulo".into(), builtin_modulo),98 ("mod".into(), builtin_mod),99 ("floor".into(), builtin_floor),100 ("ceil".into(), builtin_ceil),101 ("log".into(), builtin_log),102 ("pow".into(), builtin_pow),103 ("sqrt".into(), builtin_sqrt),104 ("sin".into(), builtin_sin),105 ("cos".into(), builtin_cos),106 ("tan".into(), builtin_tan),107 ("asin".into(), builtin_asin),108 ("acos".into(), builtin_acos),109 ("atan".into(), builtin_atan),110 ("exp".into(), builtin_exp),111 ("mantissa".into(), builtin_mantissa),112 ("exponent".into(), builtin_exponent),113 ("extVar".into(), builtin_ext_var),114 ("native".into(), builtin_native),115 ("filter".into(), builtin_filter),116 ("map".into(), builtin_map),117 ("flatMap".into(), builtin_flatmap),118 ("foldl".into(), builtin_foldl),119 ("foldr".into(), builtin_foldr),120 ("sortImpl".into(), builtin_sort_impl),121 ("format".into(), builtin_format),122 ("range".into(), builtin_range),123 ("char".into(), builtin_char),124 ("encodeUTF8".into(), builtin_encode_utf8),125 ("decodeUTF8".into(), builtin_decode_utf8),126 ("md5".into(), builtin_md5),127 ("base64".into(), builtin_base64),128 ("base64DecodeBytes".into(), builtin_base64_decode_bytes),129 ("base64Decode".into(), builtin_base64_decode),130 ("trace".into(), builtin_trace),131 ("join".into(), builtin_join),132 ("escapeStringJson".into(), builtin_escape_string_json),133 ("manifestJsonEx".into(), builtin_manifest_json_ex),134 ("manifestYamlDocImpl".into(), builtin_manifest_yaml_doc),135 ("reverse".into(), builtin_reverse),136 ("id".into(), builtin_id),137 ("strReplace".into(), builtin_str_replace),138 ("splitLimit".into(), builtin_splitlimit),139 ("parseJson".into(), builtin_parse_json),140 ("parseYaml".into(), builtin_parse_yaml),141 ("asciiUpper".into(), builtin_ascii_upper),142 ("asciiLower".into(), builtin_ascii_lower),143 ("member".into(), builtin_member),144 ("count".into(), builtin_count),145 ].iter().cloned().collect()146 };147}148149#[jrsonnet_macros::builtin]150fn builtin_length(x: Either<IStr, Either<VecVal, ObjValue>>) -> Result<usize> {151 Ok(match x {152 Either::Left(x) => x.len(),153 Either::Right(Either::Left(x)) => x.0.len(),154 Either::Right(Either::Right(x)) => x155 .fields_visibility()156 .into_iter()157 .filter(|(_k, v)| *v)158 .count(),159 })160}161162#[jrsonnet_macros::builtin]163fn builtin_type(x: Any) -> Result<IStr> {164 Ok(x.0.value_type().name().into())165}166167#[jrsonnet_macros::builtin]168fn builtin_make_array(sz: usize, func: Cc<FuncVal>) -> Result<VecVal> {169 let mut out = Vec::with_capacity(sz);170 for i in 0..sz {171 out.push(func.evaluate_values(&[Val::Num(i as f64)])?)172 }173 Ok(VecVal(out))174}175176#[jrsonnet_macros::builtin]177const fn builtin_codepoint(str: char) -> Result<u32> {178 Ok(str as u32)179}180181#[jrsonnet_macros::builtin]182fn builtin_object_fields_ex(obj: ObjValue, inc_hidden: bool) -> Result<VecVal> {183 let out = obj.fields_ex(inc_hidden);184 Ok(VecVal(out.into_iter().map(Val::Str).collect::<Vec<_>>()))185}186187#[jrsonnet_macros::builtin]188fn builtin_object_has_ex(obj: ObjValue, f: IStr, inc_hidden: bool) -> Result<bool> {189 Ok(obj.has_field_ex(f, inc_hidden))190}191192#[jrsonnet_macros::builtin]193fn builtin_parse_json(s: IStr) -> Result<Any> {194 let value: serde_json::Value = serde_json::from_str(&s)195 .map_err(|e| RuntimeError(format!("failed to parse json: {}", e).into()))?;196 Ok(Any(Val::try_from(&value)?))197}198199#[jrsonnet_macros::builtin]200fn builtin_parse_yaml(s: IStr) -> Result<Any> {201 let value = serde_yaml::Deserializer::from_str_with_quirks(202 &s,203 DeserializingQuirks { old_octals: true },204 );205 let mut out = vec![];206 for item in value {207 let value = serde_json::Value::deserialize(item)208 .map_err(|e| RuntimeError(format!("failed to parse yaml: {}", e).into()))?;209 let val = Val::try_from(&value)?;210 out.push(val);211 }212 Ok(Any(if out.is_empty() {213 Val::Null214 } else if out.len() == 1 {215 out.into_iter().next().unwrap()216 } else {217 Val::Arr(out.into())218 }))219}220221#[jrsonnet_macros::builtin]222fn builtin_slice(223 indexable: IndexableVal,224 index: Either<usize, Null>,225 end: Either<usize, Null>,226 step: Either<usize, Null>,227) -> Result<Any> {228 std_slice(indexable, index.left(), end.left(), step.left()).map(Any)229}230231#[jrsonnet_macros::builtin]232fn builtin_substr(str: IStr, from: usize, len: usize) -> Result<String> {233 Ok(str.chars().skip(from as usize).take(len as usize).collect())234}235236#[jrsonnet_macros::builtin]237fn builtin_primitive_equals(a: Any, b: Any) -> Result<bool> {238 primitive_equals(&a.0, &b.0)239}240241#[jrsonnet_macros::builtin]242fn builtin_equals(a: Any, b: Any) -> Result<bool> {243 equals(&a.0, &b.0)244}245246#[jrsonnet_macros::builtin]247fn builtin_modulo(a: f64, b: f64) -> Result<f64> {248 Ok(a % b)249}250251#[jrsonnet_macros::builtin]252fn builtin_mod(a: Either<f64, IStr>, b: Any) -> Result<Any> {253 Ok(Any(evaluate_mod_op(254 &match a {255 Either::Left(v) => Val::Num(v),256 Either::Right(s) => Val::Str(s),257 },258 &b.0,259 )?))260}261262#[jrsonnet_macros::builtin]263fn builtin_floor(x: f64) -> Result<f64> {264 Ok(x.floor())265}266267#[jrsonnet_macros::builtin]268fn builtin_ceil(x: f64) -> Result<f64> {269 Ok(x.ceil())270}271272#[jrsonnet_macros::builtin]273fn builtin_log(n: f64) -> Result<f64> {274 Ok(n.ln())275}276277#[jrsonnet_macros::builtin]278fn builtin_pow(x: f64, n: f64) -> Result<f64> {279 Ok(x.powf(n))280}281282#[jrsonnet_macros::builtin]283fn builtin_sqrt(x: PositiveF64) -> Result<f64> {284 Ok(x.0.sqrt())285}286287#[jrsonnet_macros::builtin]288fn builtin_sin(x: f64) -> Result<f64> {289 Ok(x.sin())290}291292#[jrsonnet_macros::builtin]293fn builtin_cos(x: f64) -> Result<f64> {294 Ok(x.cos())295}296297#[jrsonnet_macros::builtin]298fn builtin_tan(x: f64) -> Result<f64> {299 Ok(x.tan())300}301302#[jrsonnet_macros::builtin]303fn builtin_asin(x: f64) -> Result<f64> {304 Ok(x.asin())305}306307#[jrsonnet_macros::builtin]308fn builtin_acos(x: f64) -> Result<f64> {309 Ok(x.acos())310}311312#[jrsonnet_macros::builtin]313fn builtin_atan(x: f64) -> Result<f64> {314 Ok(x.atan())315}316317#[jrsonnet_macros::builtin]318fn builtin_exp(x: f64) -> Result<f64> {319 Ok(x.exp())320}321322fn frexp(s: f64) -> (f64, i16) {323 if 0.0 == s {324 (s, 0)325 } else {326 let lg = s.abs().log2();327 let x = (lg - lg.floor() - 1.0).exp2();328 let exp = lg.floor() + 1.0;329 (s.signum() * x, exp as i16)330 }331}332333#[jrsonnet_macros::builtin]334fn builtin_mantissa(x: f64) -> Result<f64> {335 Ok(frexp(x).0)336}337338#[jrsonnet_macros::builtin]339fn builtin_exponent(x: f64) -> Result<i16> {340 Ok(frexp(x).1)341}342343#[jrsonnet_macros::builtin]344fn builtin_ext_var(x: IStr) -> Result<Any> {345 Ok(Any(with_state(|s| s.settings().ext_vars.get(&x).cloned())346 .ok_or(UndefinedExternalVariable(x))?))347}348349#[jrsonnet_macros::builtin]350fn builtin_native(name: IStr) -> Result<Cc<FuncVal>> {351 Ok(with_state(|s| s.settings().ext_natives.get(&name).cloned())352 .map(|v| Cc::new(FuncVal::NativeExt(name.clone(), v)))353 .ok_or(UndefinedExternalFunction(name))?)354}355356#[jrsonnet_macros::builtin]357fn builtin_filter(func: Cc<FuncVal>, arr: ArrValue) -> Result<ArrValue> {358 arr.filter(|val| bool::try_from(func.evaluate_values(&[val.clone()])?))359}360361#[jrsonnet_macros::builtin]362fn builtin_map(func: Cc<FuncVal>, arr: ArrValue) -> Result<ArrValue> {363 arr.map(|val| func.evaluate_values(&[val]))364}365366#[jrsonnet_macros::builtin]367fn builtin_flatmap(func: Cc<FuncVal>, arr: IndexableVal) -> Result<IndexableVal> {368 match arr {369 IndexableVal::Str(s) => {370 let mut out = String::new();371 for c in s.chars() {372 match func.evaluate_values(&[Val::Str(c.to_string().into())])? {373 Val::Str(o) => out.push_str(&o),374 _ => throw!(RuntimeError(375 "in std.join all items should be strings".into()376 )),377 };378 }379 Ok(IndexableVal::Str(out.into()))380 }381 IndexableVal::Arr(a) => {382 let mut out = Vec::new();383 for el in a.iter() {384 let el = el?;385 match func.evaluate_values(&[el])? {386 Val::Arr(o) => {387 for oe in o.iter() {388 out.push(oe?)389 }390 }391 _ => throw!(RuntimeError(392 "in std.join all items should be arrays".into()393 )),394 };395 }396 Ok(IndexableVal::Arr(out.into()))397 }398 }399}400401#[jrsonnet_macros::builtin]402fn builtin_foldl(func: Cc<FuncVal>, arr: ArrValue, init: Any) -> Result<Any> {403 let mut acc = init.0;404 for i in arr.iter() {405 acc = func.evaluate_values(&[acc, i?])?;406 }407 Ok(Any(acc))408}409410#[jrsonnet_macros::builtin]411fn builtin_foldr(func: Cc<FuncVal>, arr: ArrValue, init: Any) -> Result<Any> {412 let mut acc = init.0;413 for i in arr.iter().rev() {414 acc = func.evaluate_values(&[i?, acc])?;415 }416 Ok(Any(acc))417}418419#[jrsonnet_macros::builtin]420#[allow(non_snake_case)]421fn builtin_sort_impl(arr: ArrValue, keyF: Cc<FuncVal>) -> Result<ArrValue> {422 if arr.len() <= 1 {423 return Ok(arr);424 }425 Ok(ArrValue::Eager(sort::sort(arr.evaluated()?, &keyF)?))426}427428#[jrsonnet_macros::builtin]429fn builtin_format(str: IStr, vals: Any) -> Result<String> {430 std_format(str, vals.0)431}432433#[jrsonnet_macros::builtin]434fn builtin_range(from: i32, to: i32) -> Result<VecVal> {435 if to < from {436 return Ok(VecVal(Vec::new()));437 }438 let mut out = Vec::with_capacity((1 + to as usize - from as usize).max(0));439 for i in from as usize..=to as usize {440 out.push(Val::Num(i as f64));441 }442 Ok(VecVal(out))443}444445#[jrsonnet_macros::builtin]446fn builtin_char(n: u32) -> Result<char> {447 Ok(std::char::from_u32(n as u32).ok_or_else(|| InvalidUnicodeCodepointGot(n as u32))?)448}449450#[jrsonnet_macros::builtin]451fn builtin_encode_utf8(str: IStr) -> Result<VecVal> {452 Ok(VecVal(453 str.bytes()454 .map(|b| Val::Num(b as f64))455 .collect::<Vec<Val>>(),456 ))457}458459#[jrsonnet_macros::builtin]460fn builtin_decode_utf8(arr: Vec<u8>) -> Result<String> {461 Ok(String::from_utf8(arr).map_err(|_| RuntimeError("bad utf8".into()))?)462}463464#[jrsonnet_macros::builtin]465fn builtin_md5(str: IStr) -> Result<String> {466 Ok(format!("{:x}", md5::compute(&str.as_bytes())))467}468469fn builtin_trace(context: Context, loc: &ExprLocation, args: &ArgsDesc) -> Result<Val> {470 parse_args!(context, "trace", args, 2, [471 0, str: ty!(string) => Val::Str;472 1, rest: ty!(any);473 ], {474 eprint!("TRACE:");475 with_state(|s|{476 let locs = s.map_source_locations(&loc.0, &[loc.1]);477 eprint!(" {}:{}", loc.0.file_name().unwrap().to_str().unwrap(), locs[0].line);478 });479 eprintln!(" {}", str);480 Ok(rest)481 })482}483484#[jrsonnet_macros::builtin]485fn builtin_base64(input: Either<Vec<u8>, IStr>) -> Result<String> {486 Ok(match input {487 Either::Left(a) => base64::encode(a),488 Either::Right(l) => base64::encode(l.bytes().collect::<Vec<_>>()),489 })490}491492#[jrsonnet_macros::builtin]493fn builtin_base64_decode_bytes(input: IStr) -> Result<Vec<u8>> {494 Ok(base64::decode(&input.as_bytes()).map_err(|_| RuntimeError("bad base64".into()))?)495}496497#[jrsonnet_macros::builtin]498fn builtin_base64_decode(input: IStr) -> Result<String> {499 let bytes = base64::decode(&input.as_bytes()).map_err(|_| RuntimeError("bad base64".into()))?;500 Ok(String::from_utf8(bytes).map_err(|_| RuntimeError("bad utf8".into()))?)501}502503#[jrsonnet_macros::builtin]504fn builtin_join(sep: IndexableVal, arr: ArrValue) -> Result<IndexableVal> {505 Ok(match sep {506 IndexableVal::Arr(joiner_items) => {507 let mut out = Vec::new();508509 let mut first = true;510 for item in arr.iter() {511 let item = item?.clone();512 if let Val::Arr(items) = item {513 if !first {514 out.reserve(joiner_items.len());515 516 for item in joiner_items.iter() {517 out.push(item?);518 }519 }520 first = false;521 out.reserve(items.len());522 523 for item in items.iter() {524 out.push(item?);525 }526 } else {527 throw!(RuntimeError(528 "in std.join all items should be arrays".into()529 ));530 }531 }532533 IndexableVal::Arr(out.into())534 }535 IndexableVal::Str(sep) => {536 let mut out = String::new();537538 let mut first = true;539 for item in arr.iter() {540 let item = item?.clone();541 if let Val::Str(item) = item {542 if !first {543 out += &sep;544 }545 first = false;546 out += &item;547 } else {548 throw!(RuntimeError(549 "in std.join all items should be strings".into()550 ));551 }552 }553554 IndexableVal::Str(out.into())555 }556 })557}558559#[jrsonnet_macros::builtin]560fn builtin_escape_string_json(str_: IStr) -> Result<String> {561 Ok(escape_string_json(&str_))562}563564#[jrsonnet_macros::builtin]565fn builtin_manifest_json_ex(value: Any, indent: IStr) -> Result<String> {566 manifest_json_ex(567 &value.0,568 &ManifestJsonOptions {569 padding: &indent,570 mtype: ManifestType::Std,571 },572 )573}574575#[jrsonnet_macros::builtin]576fn builtin_manifest_yaml_doc(577 value: Any,578 indent_array_in_object: bool,579 quote_keys: bool,580) -> Result<String> {581 manifest_yaml_ex(582 &value.0,583 &ManifestYamlOptions {584 padding: " ",585 arr_element_padding: if indent_array_in_object { " " } else { "" },586 quote_keys,587 },588 )589}590591#[jrsonnet_macros::builtin]592fn builtin_reverse(value: ArrValue) -> Result<ArrValue> {593 Ok(value.reversed())594}595596#[jrsonnet_macros::builtin]597const fn builtin_id(v: Any) -> Result<Any> {598 Ok(v)599}600601#[jrsonnet_macros::builtin]602fn builtin_str_replace(str: String, from: IStr, to: IStr) -> Result<String> {603 Ok(str.replace(&from as &str, &to as &str))604}605606#[jrsonnet_macros::builtin]607fn builtin_splitlimit(str: IStr, c: char, maxsplits: Either<usize, M1>) -> Result<VecVal> {608 Ok(VecVal(match maxsplits {609 Either::Left(n) => str.splitn(n + 1, c).map(|s| Val::Str(s.into())).collect(),610 Either::Right(_) => str.split(c).map(|s| Val::Str(s.into())).collect(),611 }))612}613614#[jrsonnet_macros::builtin]615fn builtin_ascii_upper(str: IStr) -> Result<String> {616 Ok(str.to_ascii_uppercase())617}618619#[jrsonnet_macros::builtin]620fn builtin_ascii_lower(str: IStr) -> Result<String> {621 Ok(str.to_ascii_lowercase())622}623624#[jrsonnet_macros::builtin]625fn builtin_member(arr: IndexableVal, x: Any) -> Result<bool> {626 match arr {627 IndexableVal::Str(s) => {628 let x: IStr = IStr::try_from(x.0)?;629 Ok(!x.is_empty() && s.contains(&*x))630 }631 IndexableVal::Arr(a) => {632 for item in a.iter() {633 let item = item?;634 if equals(&item, &x.0)? {635 return Ok(true);636 }637 }638 Ok(false)639 }640 }641}642643#[jrsonnet_macros::builtin]644fn builtin_count(arr: Vec<Any>, v: Any) -> Result<usize> {645 let mut count = 0;646 for item in arr.iter() {647 if equals(&item.0, &v.0)? {648 count += 1;649 }650 }651 Ok(count)652}653654pub fn call_builtin(655 context: Context,656 loc: &ExprLocation,657 name: &str,658 args: &ArgsDesc,659) -> Result<Val> {660 BUILTINS661 .with(|builtins| builtins.get(name).copied())662 .ok_or_else(|| IntrinsicNotFound(name.into()))?(context, loc, args)663}