12#![allow(clippy::unnecessary_wraps)]34use std::collections::HashMap;56use format::{format_arr, format_obj};7use jrsonnet_gcmodule::Cc;8use jrsonnet_interner::{IBytes, IStr};9use serde::Deserialize;10use serde_yaml::DeserializingQuirks;1112use crate::{13 error::{Error::*, Result},14 function::{builtin::StaticBuiltin, ArgLike, CallLocation, FuncVal},15 operator::evaluate_mod_op,16 stdlib::manifest::{manifest_yaml_ex, ManifestYamlOptions},17 throw,18 typed::{Any, BoundedUsize, Either2, Either4, PositiveF64, Typed, VecVal, M1},19 val::{equals, primitive_equals, ArrValue, IndexableVal, Slice},20 Either, ObjValue, State, Val,21};2223pub mod expr;24pub use expr::*;2526use self::manifest::{escape_string_json, manifest_json_ex, ManifestJsonOptions, ManifestType};2728pub mod format;29pub mod manifest;30pub mod sort;3132pub fn std_format(s: State, str: IStr, vals: Val) -> Result<String> {33 s.push(34 CallLocation::native(),35 || format!("std.format of {}", str),36 || {37 Ok(match vals {38 Val::Arr(vals) => format_arr(s.clone(), &str, &vals.evaluated(s.clone())?)?,39 Val::Obj(obj) => format_obj(s.clone(), &str, &obj)?,40 o => format_arr(s.clone(), &str, &[o])?,41 })42 },43 )44}4546pub fn std_slice(47 indexable: IndexableVal,48 index: Option<BoundedUsize<0, { i32::MAX as usize }>>,49 end: Option<BoundedUsize<0, { i32::MAX as usize }>>,50 step: Option<BoundedUsize<1, { i32::MAX as usize }>>,51) -> Result<Val> {52 match &indexable {53 IndexableVal::Str(s) => {54 let index = index.as_deref().copied().unwrap_or(0);55 let end = end.as_deref().copied().unwrap_or(usize::MAX);56 let step = step.as_deref().copied().unwrap_or(1);5758 if index >= end {59 return Ok(Val::Str("".into()));60 }6162 Ok(Val::Str(63 (s.chars()64 .skip(index)65 .take(end - index)66 .step_by(step)67 .collect::<String>())68 .into(),69 ))70 }71 IndexableVal::Arr(arr) => {72 let index = index.as_deref().copied().unwrap_or(0);73 let end = end.as_deref().copied().unwrap_or(usize::MAX).min(arr.len());74 let step = step.as_deref().copied().unwrap_or(1);7576 if index >= end {77 return Ok(Val::Arr(ArrValue::new_eager()));78 }7980 Ok(Val::Arr(ArrValue::Slice(Box::new(Slice {81 inner: arr.clone(),82 from: index as u32,83 to: end as u32,84 step: step as u32,85 }))))86 }87 }88}8990type BuiltinsType = HashMap<IStr, &'static dyn StaticBuiltin>;9192thread_local! {93 pub static BUILTINS: BuiltinsType = {94 [95 ("length".into(), builtin_length::INST),96 ("type".into(), builtin_type::INST),97 ("makeArray".into(), builtin_make_array::INST),98 ("codepoint".into(), builtin_codepoint::INST),99 ("objectFieldsEx".into(), builtin_object_fields_ex::INST),100 ("objectHasEx".into(), builtin_object_has_ex::INST),101 ("slice".into(), builtin_slice::INST),102 ("substr".into(), builtin_substr::INST),103 ("primitiveEquals".into(), builtin_primitive_equals::INST),104 ("equals".into(), builtin_equals::INST),105 ("modulo".into(), builtin_modulo::INST),106 ("mod".into(), builtin_mod::INST),107 ("floor".into(), builtin_floor::INST),108 ("ceil".into(), builtin_ceil::INST),109 ("log".into(), builtin_log::INST),110 ("pow".into(), builtin_pow::INST),111 ("sqrt".into(), builtin_sqrt::INST),112 ("sin".into(), builtin_sin::INST),113 ("cos".into(), builtin_cos::INST),114 ("tan".into(), builtin_tan::INST),115 ("asin".into(), builtin_asin::INST),116 ("acos".into(), builtin_acos::INST),117 ("atan".into(), builtin_atan::INST),118 ("exp".into(), builtin_exp::INST),119 ("mantissa".into(), builtin_mantissa::INST),120 ("exponent".into(), builtin_exponent::INST),121 ("extVar".into(), builtin_ext_var::INST),122 ("native".into(), builtin_native::INST),123 ("filter".into(), builtin_filter::INST),124 ("map".into(), builtin_map::INST),125 ("flatMap".into(), builtin_flatmap::INST),126 ("foldl".into(), builtin_foldl::INST),127 ("foldr".into(), builtin_foldr::INST),128 ("sort".into(), builtin_sort::INST),129 ("format".into(), builtin_format::INST),130 ("range".into(), builtin_range::INST),131 ("char".into(), builtin_char::INST),132 ("encodeUTF8".into(), builtin_encode_utf8::INST),133 ("decodeUTF8".into(), builtin_decode_utf8::INST),134 ("md5".into(), builtin_md5::INST),135 ("base64".into(), builtin_base64::INST),136 ("base64DecodeBytes".into(), builtin_base64_decode_bytes::INST),137 ("base64Decode".into(), builtin_base64_decode::INST),138 ("trace".into(), builtin_trace::INST),139 ("join".into(), builtin_join::INST),140 ("escapeStringJson".into(), builtin_escape_string_json::INST),141 ("manifestJsonEx".into(), builtin_manifest_json_ex::INST),142 ("manifestYamlDoc".into(), builtin_manifest_yaml_doc::INST),143 ("reverse".into(), builtin_reverse::INST),144 ("strReplace".into(), builtin_str_replace::INST),145 ("splitLimit".into(), builtin_splitlimit::INST),146 ("parseJson".into(), builtin_parse_json::INST),147 ("parseYaml".into(), builtin_parse_yaml::INST),148 ("asciiUpper".into(), builtin_ascii_upper::INST),149 ("asciiLower".into(), builtin_ascii_lower::INST),150 ("member".into(), builtin_member::INST),151 ("count".into(), builtin_count::INST),152 ("any".into(), builtin_any::INST),153 ("all".into(), builtin_all::INST),154 ].iter().cloned().collect()155 };156}157158#[jrsonnet_macros::builtin]159fn builtin_length(x: Either![IStr, ArrValue, ObjValue, FuncVal]) -> Result<usize> {160 use Either4::*;161 Ok(match x {162 A(x) => x.chars().count(),163 B(x) => x.len(),164 C(x) => x.len(),165 D(f) => f.params_len(),166 })167}168169#[jrsonnet_macros::builtin]170fn builtin_type(x: Any) -> Result<IStr> {171 Ok(x.0.value_type().name().into())172}173174#[jrsonnet_macros::builtin]175fn builtin_make_array(s: State, sz: usize, func: FuncVal) -> Result<VecVal> {176 let mut out = Vec::with_capacity(sz);177 for i in 0..sz {178 out.push(func.evaluate_simple(s.clone(), &(i as f64,))?);179 }180 Ok(VecVal(Cc::new(out)))181}182183#[jrsonnet_macros::builtin]184const fn builtin_codepoint(str: char) -> Result<u32> {185 Ok(str as u32)186}187188#[jrsonnet_macros::builtin]189fn builtin_object_fields_ex(190 obj: ObjValue,191 inc_hidden: bool,192 #[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,193) -> Result<VecVal> {194 #[cfg(feature = "exp-preserve-order")]195 let preserve_order = preserve_order.unwrap_or(false);196 let out = obj.fields_ex(197 inc_hidden,198 #[cfg(feature = "exp-preserve-order")]199 preserve_order,200 );201 Ok(VecVal(Cc::new(202 out.into_iter().map(Val::Str).collect::<Vec<_>>(),203 )))204}205206#[jrsonnet_macros::builtin]207fn builtin_object_has_ex(obj: ObjValue, f: IStr, inc_hidden: bool) -> Result<bool> {208 Ok(obj.has_field_ex(f, inc_hidden))209}210211#[jrsonnet_macros::builtin]212fn builtin_parse_json(st: State, s: IStr) -> Result<Any> {213 use serde_json::Value;214 let value: Value = serde_json::from_str(&s)215 .map_err(|e| RuntimeError(format!("failed to parse json: {}", e).into()))?;216 Ok(Any(Value::into_untyped(value, st)?))217}218219#[jrsonnet_macros::builtin]220fn builtin_parse_yaml(st: State, s: IStr) -> Result<Any> {221 use serde_json::Value;222 let value = serde_yaml::Deserializer::from_str_with_quirks(223 &s,224 DeserializingQuirks { old_octals: true },225 );226 let mut out = vec![];227 for item in value {228 let value = Value::deserialize(item)229 .map_err(|e| RuntimeError(format!("failed to parse yaml: {}", e).into()))?;230 let val = Value::into_untyped(value, st.clone())?;231 out.push(val);232 }233 Ok(Any(if out.is_empty() {234 Val::Null235 } else if out.len() == 1 {236 out.into_iter().next().unwrap()237 } else {238 Val::Arr(out.into())239 }))240}241242#[jrsonnet_macros::builtin]243fn builtin_slice(244 indexable: IndexableVal,245 index: Option<BoundedUsize<0, { i32::MAX as usize }>>,246 end: Option<BoundedUsize<0, { i32::MAX as usize }>>,247 step: Option<BoundedUsize<1, { i32::MAX as usize }>>,248) -> Result<Any> {249 std_slice(indexable, index, end, step).map(Any)250}251252#[jrsonnet_macros::builtin]253fn builtin_substr(str: IStr, from: usize, len: usize) -> Result<String> {254 Ok(str.chars().skip(from as usize).take(len as usize).collect())255}256257#[jrsonnet_macros::builtin]258fn builtin_primitive_equals(a: Any, b: Any) -> Result<bool> {259 primitive_equals(&a.0, &b.0)260}261262#[jrsonnet_macros::builtin]263fn builtin_equals(s: State, a: Any, b: Any) -> Result<bool> {264 equals(s, &a.0, &b.0)265}266267#[jrsonnet_macros::builtin]268fn builtin_modulo(a: f64, b: f64) -> Result<f64> {269 Ok(a % b)270}271272#[jrsonnet_macros::builtin]273fn builtin_mod(s: State, a: Either![f64, IStr], b: Any) -> Result<Any> {274 use Either2::*;275 Ok(Any(evaluate_mod_op(276 s,277 &match a {278 A(v) => Val::Num(v),279 B(s) => Val::Str(s),280 },281 &b.0,282 )?))283}284285#[jrsonnet_macros::builtin]286fn builtin_floor(x: f64) -> Result<f64> {287 Ok(x.floor())288}289290#[jrsonnet_macros::builtin]291fn builtin_ceil(x: f64) -> Result<f64> {292 Ok(x.ceil())293}294295#[jrsonnet_macros::builtin]296fn builtin_log(n: f64) -> Result<f64> {297 Ok(n.ln())298}299300#[jrsonnet_macros::builtin]301fn builtin_pow(x: f64, n: f64) -> Result<f64> {302 Ok(x.powf(n))303}304305#[jrsonnet_macros::builtin]306fn builtin_sqrt(x: PositiveF64) -> Result<f64> {307 Ok(x.0.sqrt())308}309310#[jrsonnet_macros::builtin]311fn builtin_sin(x: f64) -> Result<f64> {312 Ok(x.sin())313}314315#[jrsonnet_macros::builtin]316fn builtin_cos(x: f64) -> Result<f64> {317 Ok(x.cos())318}319320#[jrsonnet_macros::builtin]321fn builtin_tan(x: f64) -> Result<f64> {322 Ok(x.tan())323}324325#[jrsonnet_macros::builtin]326fn builtin_asin(x: f64) -> Result<f64> {327 Ok(x.asin())328}329330#[jrsonnet_macros::builtin]331fn builtin_acos(x: f64) -> Result<f64> {332 Ok(x.acos())333}334335#[jrsonnet_macros::builtin]336fn builtin_atan(x: f64) -> Result<f64> {337 Ok(x.atan())338}339340#[jrsonnet_macros::builtin]341fn builtin_exp(x: f64) -> Result<f64> {342 Ok(x.exp())343}344345fn frexp(s: f64) -> (f64, i16) {346 if 0.0 == s {347 (s, 0)348 } else {349 let lg = s.abs().log2();350 let x = (lg - lg.floor() - 1.0).exp2();351 let exp = lg.floor() + 1.0;352 (s.signum() * x, exp as i16)353 }354}355356#[jrsonnet_macros::builtin]357fn builtin_mantissa(x: f64) -> Result<f64> {358 Ok(frexp(x).0)359}360361#[jrsonnet_macros::builtin]362fn builtin_exponent(x: f64) -> Result<i16> {363 Ok(frexp(x).1)364}365366#[jrsonnet_macros::builtin]367fn builtin_ext_var(s: State, x: IStr) -> Result<Any> {368 let ctx = s.create_default_context();369 Ok(Any(s370 .clone()371 .settings()372 .ext_vars373 .get(&x)374 .cloned()375 .ok_or(UndefinedExternalVariable(x))?376 .evaluate_arg(s.clone(), ctx, true)?377 .evaluate(s)?))378}379380#[jrsonnet_macros::builtin]381fn builtin_native(s: State, name: IStr) -> Result<Any> {382 Ok(Any(s383 .settings()384 .ext_natives385 .get(&name)386 .cloned()387 .map_or(Val::Null, |v| {388 Val::Func(FuncVal::Builtin(v.clone()))389 })))390}391392#[jrsonnet_macros::builtin]393fn builtin_filter(s: State, func: FuncVal, arr: ArrValue) -> Result<ArrValue> {394 arr.filter(s.clone(), |val| {395 bool::from_untyped(396 func.evaluate_simple(s.clone(), &(Any(val.clone()),))?,397 s.clone(),398 )399 })400}401402#[jrsonnet_macros::builtin]403fn builtin_map(s: State, func: FuncVal, arr: ArrValue) -> Result<ArrValue> {404 arr.map(s.clone(), |val| {405 func.evaluate_simple(s.clone(), &(Any(val),))406 })407}408409#[jrsonnet_macros::builtin]410fn builtin_flatmap(s: State, func: FuncVal, arr: IndexableVal) -> Result<IndexableVal> {411 match arr {412 IndexableVal::Str(str) => {413 let mut out = String::new();414 for c in str.chars() {415 match func.evaluate_simple(s.clone(), &(c.to_string(),))? {416 Val::Str(o) => out.push_str(&o),417 Val::Null => continue,418 _ => throw!(RuntimeError(419 "in std.join all items should be strings".into()420 )),421 };422 }423 Ok(IndexableVal::Str(out.into()))424 }425 IndexableVal::Arr(a) => {426 let mut out = Vec::new();427 for el in a.iter(s.clone()) {428 let el = el?;429 match func.evaluate_simple(s.clone(), &(Any(el),))? {430 Val::Arr(o) => {431 for oe in o.iter(s.clone()) {432 out.push(oe?);433 }434 }435 Val::Null => continue,436 _ => throw!(RuntimeError(437 "in std.join all items should be arrays".into()438 )),439 };440 }441 Ok(IndexableVal::Arr(out.into()))442 }443 }444}445446#[jrsonnet_macros::builtin]447fn builtin_foldl(s: State, func: FuncVal, arr: ArrValue, init: Any) -> Result<Any> {448 let mut acc = init.0;449 for i in arr.iter(s.clone()) {450 acc = func.evaluate_simple(s.clone(), &(Any(acc), Any(i?)))?;451 }452 Ok(Any(acc))453}454455#[jrsonnet_macros::builtin]456fn builtin_foldr(s: State, func: FuncVal, arr: ArrValue, init: Any) -> Result<Any> {457 let mut acc = init.0;458 for i in arr.iter(s.clone()).rev() {459 acc = func.evaluate_simple(s.clone(), &(Any(i?), Any(acc)))?;460 }461 Ok(Any(acc))462}463464#[jrsonnet_macros::builtin]465#[allow(non_snake_case)]466fn builtin_sort(s: State, arr: ArrValue, keyF: Option<FuncVal>) -> Result<ArrValue> {467 if arr.len() <= 1 {468 return Ok(arr);469 }470 Ok(ArrValue::Eager(sort::sort(471 s.clone(),472 arr.evaluated(s)?,473 keyF.unwrap_or_else(FuncVal::identity),474 )?))475}476477#[jrsonnet_macros::builtin]478fn builtin_format(s: State, str: IStr, vals: Any) -> Result<String> {479 std_format(s, str, vals.0)480}481482#[jrsonnet_macros::builtin]483fn builtin_range(from: i32, to: i32) -> Result<ArrValue> {484 if to < from {485 return Ok(ArrValue::new_eager());486 }487 Ok(ArrValue::new_range(from, to))488}489490#[jrsonnet_macros::builtin]491fn builtin_char(n: u32) -> Result<char> {492 Ok(std::char::from_u32(n as u32).ok_or(InvalidUnicodeCodepointGot(n as u32))?)493}494495#[jrsonnet_macros::builtin]496fn builtin_encode_utf8(str: IStr) -> Result<IBytes> {497 Ok(str.cast_bytes())498}499500#[jrsonnet_macros::builtin]501fn builtin_decode_utf8(arr: IBytes) -> Result<IStr> {502 Ok(arr503 .cast_str()504 .ok_or_else(|| RuntimeError("bad utf8".into()))?)505}506507#[jrsonnet_macros::builtin]508fn builtin_md5(str: IStr) -> Result<String> {509 Ok(format!("{:x}", md5::compute(&str.as_bytes())))510}511512#[jrsonnet_macros::builtin]513fn builtin_trace(s: State, loc: CallLocation, str: IStr, rest: Any) -> Result<Any> {514 eprint!("TRACE:");515 if let Some(loc) = loc.0 {516 let locs = s.map_source_locations(loc.0.clone(), &[loc.1]);517 eprint!(" {}:{}", loc.0.short_display(), locs[0].line);518 }519 eprintln!(" {}", str);520 Ok(rest) as Result<Any>521}522523#[jrsonnet_macros::builtin]524fn builtin_base64(input: Either![IBytes, IStr]) -> Result<String> {525 use Either2::*;526 Ok(match input {527 A(a) => base64::encode(a.as_slice()),528 B(l) => base64::encode(l.bytes().collect::<Vec<_>>()),529 })530}531532#[jrsonnet_macros::builtin]533fn builtin_base64_decode_bytes(input: IStr) -> Result<IBytes> {534 Ok(base64::decode(&input.as_bytes())535 .map_err(|_| RuntimeError("bad base64".into()))?536 .as_slice()537 .into())538}539540#[jrsonnet_macros::builtin]541fn builtin_base64_decode(input: IStr) -> Result<String> {542 let bytes = base64::decode(&input.as_bytes()).map_err(|_| RuntimeError("bad base64".into()))?;543 Ok(String::from_utf8(bytes).map_err(|_| RuntimeError("bad utf8".into()))?)544}545546#[jrsonnet_macros::builtin]547fn builtin_join(s: State, sep: IndexableVal, arr: ArrValue) -> Result<IndexableVal> {548 Ok(match sep {549 IndexableVal::Arr(joiner_items) => {550 let mut out = Vec::new();551552 let mut first = true;553 for item in arr.iter(s.clone()) {554 let item = item?.clone();555 if let Val::Arr(items) = item {556 if !first {557 out.reserve(joiner_items.len());558 559 for item in joiner_items.iter(s.clone()) {560 out.push(item?);561 }562 }563 first = false;564 out.reserve(items.len());565 for item in items.iter(s.clone()) {566 out.push(item?);567 }568 } else if matches!(item, Val::Null) {569 continue;570 } else {571 throw!(RuntimeError(572 "in std.join all items should be arrays".into()573 ));574 }575 }576577 IndexableVal::Arr(out.into())578 }579 IndexableVal::Str(sep) => {580 let mut out = String::new();581582 let mut first = true;583 for item in arr.iter(s) {584 let item = item?.clone();585 if let Val::Str(item) = item {586 if !first {587 out += &sep;588 }589 first = false;590 out += &item;591 } else if matches!(item, Val::Null) {592 continue;593 } else {594 throw!(RuntimeError(595 "in std.join all items should be strings".into()596 ));597 }598 }599600 IndexableVal::Str(out.into())601 }602 })603}604605#[jrsonnet_macros::builtin]606fn builtin_escape_string_json(str_: IStr) -> Result<String> {607 Ok(escape_string_json(&str_))608}609610#[jrsonnet_macros::builtin]611fn builtin_manifest_json_ex(612 s: State,613 value: Any,614 indent: IStr,615 newline: Option<IStr>,616 key_val_sep: Option<IStr>,617 #[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,618) -> Result<String> {619 let newline = newline.as_deref().unwrap_or("\n");620 let key_val_sep = key_val_sep.as_deref().unwrap_or(": ");621 manifest_json_ex(622 s,623 &value.0,624 &ManifestJsonOptions {625 padding: &indent,626 mtype: ManifestType::Std,627 newline,628 key_val_sep,629 #[cfg(feature = "exp-preserve-order")]630 preserve_order: preserve_order.unwrap_or(false),631 },632 )633}634635#[jrsonnet_macros::builtin]636fn builtin_manifest_yaml_doc(637 s: State,638 value: Any,639 indent_array_in_object: Option<bool>,640 quote_keys: Option<bool>,641 #[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,642) -> Result<String> {643 manifest_yaml_ex(644 s,645 &value.0,646 &ManifestYamlOptions {647 padding: " ",648 arr_element_padding: if indent_array_in_object.unwrap_or(false) {649 " "650 } else {651 ""652 },653 quote_keys: quote_keys.unwrap_or(true),654 #[cfg(feature = "exp-preserve-order")]655 preserve_order: preserve_order.unwrap_or(false),656 },657 )658}659660#[jrsonnet_macros::builtin]661fn builtin_reverse(value: ArrValue) -> Result<ArrValue> {662 Ok(value.reversed())663}664665#[jrsonnet_macros::builtin]666fn builtin_str_replace(str: String, from: IStr, to: IStr) -> Result<String> {667 Ok(str.replace(&from as &str, &to as &str))668}669670#[jrsonnet_macros::builtin]671fn builtin_splitlimit(str: IStr, c: IStr, maxsplits: Either![usize, M1]) -> Result<VecVal> {672 use Either2::*;673 Ok(VecVal(Cc::new(match maxsplits {674 A(n) => str675 .splitn(n + 1, &c as &str)676 .map(|s| Val::Str(s.into()))677 .collect(),678 B(_) => str.split(&c as &str).map(|s| Val::Str(s.into())).collect(),679 })))680}681682#[jrsonnet_macros::builtin]683fn builtin_ascii_upper(str: IStr) -> Result<String> {684 Ok(str.to_ascii_uppercase())685}686687#[jrsonnet_macros::builtin]688fn builtin_ascii_lower(str: IStr) -> Result<String> {689 Ok(str.to_ascii_lowercase())690}691692#[jrsonnet_macros::builtin]693fn builtin_member(s: State, arr: IndexableVal, x: Any) -> Result<bool> {694 match arr {695 IndexableVal::Str(str) => {696 let x: IStr = IStr::from_untyped(x.0, s)?;697 Ok(!x.is_empty() && str.contains(&*x))698 }699 IndexableVal::Arr(a) => {700 for item in a.iter(s.clone()) {701 let item = item?;702 if equals(s.clone(), &item, &x.0)? {703 return Ok(true);704 }705 }706 Ok(false)707 }708 }709}710711#[jrsonnet_macros::builtin]712fn builtin_count(s: State, arr: Vec<Any>, v: Any) -> Result<usize> {713 let mut count = 0;714 for item in &arr {715 if equals(s.clone(), &item.0, &v.0)? {716 count += 1;717 }718 }719 Ok(count)720}721722#[jrsonnet_macros::builtin]723fn builtin_any(s: State, arr: ArrValue) -> Result<bool> {724 for v in arr.iter(s.clone()) {725 let v = bool::from_untyped(v?, s.clone())?;726 if v {727 return Ok(true);728 }729 }730 Ok(false)731}732733#[jrsonnet_macros::builtin]734fn builtin_all(s: State, arr: ArrValue) -> Result<bool> {735 for v in arr.iter(s.clone()) {736 let v = bool::from_untyped(v?, s.clone())?;737 if !v {738 return Ok(false);739 }740 }741 Ok(true)742}