1use std::collections::HashMap;23use format::{format_arr, format_obj};4use gcmodule::Cc;5use jrsonnet_interner::IStr;6use serde::Deserialize;7use serde_yaml::DeserializingQuirks;89use crate::{10 builtin::manifest::{manifest_yaml_ex, ManifestYamlOptions},11 error::{Error::*, Result},12 function::{CallLocation, StaticBuiltin},13 operator::evaluate_mod_op,14 throw,15 typed::{Any, BoundedUsize, Bytes, Either2, Either4, PositiveF64, Typed, VecVal, M1},16 val::{equals, primitive_equals, ArrValue, FuncVal, IndexableVal, Slice},17 Either, ObjValue, State, Val,18};1920pub mod stdlib;21pub use stdlib::*;2223use self::manifest::{escape_string_json, manifest_json_ex, ManifestJsonOptions, ManifestType};2425pub mod format;26pub mod manifest;27pub mod sort;2829pub fn std_format(s: State, str: IStr, vals: Val) -> Result<String> {30 s.push(31 CallLocation::native(),32 || format!("std.format of {}", str),33 || {34 Ok(match vals {35 Val::Arr(vals) => format_arr(s.clone(), &str, &vals.evaluated(s.clone())?)?,36 Val::Obj(obj) => format_obj(s.clone(), &str, &obj)?,37 o => format_arr(s.clone(), &str, &[o])?,38 })39 },40 )41}4243pub fn std_slice(44 indexable: IndexableVal,45 index: Option<BoundedUsize<0, { i32::MAX as usize }>>,46 end: Option<BoundedUsize<0, { i32::MAX as usize }>>,47 step: Option<BoundedUsize<1, { i32::MAX as usize }>>,48) -> Result<Val> {49 match &indexable {50 IndexableVal::Str(s) => {51 let index = index.as_deref().copied().unwrap_or(0);52 let end = end.as_deref().copied().unwrap_or(usize::MAX);53 let step = step.as_deref().copied().unwrap_or(1);5455 if index >= end {56 return Ok(Val::Str("".into()));57 }5859 Ok(Val::Str(60 (s.chars()61 .skip(index)62 .take(end - index)63 .step_by(step)64 .collect::<String>())65 .into(),66 ))67 }68 IndexableVal::Arr(arr) => {69 let index = index.as_deref().copied().unwrap_or(0);70 let end = end.as_deref().copied().unwrap_or(usize::MAX).min(arr.len());71 let step = step.as_deref().copied().unwrap_or(1);7273 if index >= end {74 return Ok(Val::Arr(ArrValue::new_eager()));75 }7677 Ok(Val::Arr(ArrValue::Slice(Box::new(Slice {78 inner: arr.clone(),79 from: index as u32,80 to: end as u32,81 step: step as u32,82 }))))83 }84 }85}8687type BuiltinsType = HashMap<IStr, &'static dyn StaticBuiltin>;8889thread_local! {90 pub static BUILTINS: BuiltinsType = {91 [92 ("length".into(), builtin_length::INST),93 ("type".into(), builtin_type::INST),94 ("makeArray".into(), builtin_make_array::INST),95 ("codepoint".into(), builtin_codepoint::INST),96 ("objectFieldsEx".into(), builtin_object_fields_ex::INST),97 ("objectHasEx".into(), builtin_object_has_ex::INST),98 ("slice".into(), builtin_slice::INST),99 ("substr".into(), builtin_substr::INST),100 ("primitiveEquals".into(), builtin_primitive_equals::INST),101 ("equals".into(), builtin_equals::INST),102 ("modulo".into(), builtin_modulo::INST),103 ("mod".into(), builtin_mod::INST),104 ("floor".into(), builtin_floor::INST),105 ("ceil".into(), builtin_ceil::INST),106 ("log".into(), builtin_log::INST),107 ("pow".into(), builtin_pow::INST),108 ("sqrt".into(), builtin_sqrt::INST),109 ("sin".into(), builtin_sin::INST),110 ("cos".into(), builtin_cos::INST),111 ("tan".into(), builtin_tan::INST),112 ("asin".into(), builtin_asin::INST),113 ("acos".into(), builtin_acos::INST),114 ("atan".into(), builtin_atan::INST),115 ("exp".into(), builtin_exp::INST),116 ("mantissa".into(), builtin_mantissa::INST),117 ("exponent".into(), builtin_exponent::INST),118 ("extVar".into(), builtin_ext_var::INST),119 ("native".into(), builtin_native::INST),120 ("filter".into(), builtin_filter::INST),121 ("map".into(), builtin_map::INST),122 ("flatMap".into(), builtin_flatmap::INST),123 ("foldl".into(), builtin_foldl::INST),124 ("foldr".into(), builtin_foldr::INST),125 ("sort".into(), builtin_sort::INST),126 ("format".into(), builtin_format::INST),127 ("range".into(), builtin_range::INST),128 ("char".into(), builtin_char::INST),129 ("encodeUTF8".into(), builtin_encode_utf8::INST),130 ("decodeUTF8".into(), builtin_decode_utf8::INST),131 ("md5".into(), builtin_md5::INST),132 ("base64".into(), builtin_base64::INST),133 ("base64DecodeBytes".into(), builtin_base64_decode_bytes::INST),134 ("base64Decode".into(), builtin_base64_decode::INST),135 ("trace".into(), builtin_trace::INST),136 ("join".into(), builtin_join::INST),137 ("escapeStringJson".into(), builtin_escape_string_json::INST),138 ("manifestJsonEx".into(), builtin_manifest_json_ex::INST),139 ("manifestYamlDoc".into(), builtin_manifest_yaml_doc::INST),140 ("reverse".into(), builtin_reverse::INST),141 ("id".into(), builtin_id::INST),142 ("strReplace".into(), builtin_str_replace::INST),143 ("splitLimit".into(), builtin_splitlimit::INST),144 ("parseJson".into(), builtin_parse_json::INST),145 ("parseYaml".into(), builtin_parse_yaml::INST),146 ("asciiUpper".into(), builtin_ascii_upper::INST),147 ("asciiLower".into(), builtin_ascii_lower::INST),148 ("member".into(), builtin_member::INST),149 ("count".into(), builtin_count::INST),150 ("any".into(), builtin_any::INST),151 ("all".into(), builtin_all::INST),152 ].iter().cloned().collect()153 };154}155156#[jrsonnet_macros::builtin]157fn builtin_length(x: Either![IStr, ArrValue, ObjValue, FuncVal]) -> Result<usize> {158 use Either4::*;159 Ok(match x {160 A(x) => x.chars().count(),161 B(x) => x.len(),162 C(x) => x.len(),163 D(f) => f.args_len(),164 })165}166167#[jrsonnet_macros::builtin]168fn builtin_type(x: Any) -> Result<IStr> {169 Ok(x.0.value_type().name().into())170}171172#[jrsonnet_macros::builtin]173fn builtin_make_array(s: State, sz: usize, func: FuncVal) -> Result<VecVal> {174 let mut out = Vec::with_capacity(sz);175 for i in 0..sz {176 out.push(func.evaluate_simple(s.clone(), &[i as f64].as_slice())?)177 }178 Ok(VecVal(Cc::new(out)))179}180181#[jrsonnet_macros::builtin]182const fn builtin_codepoint(str: char) -> Result<u32> {183 Ok(str as u32)184}185186#[jrsonnet_macros::builtin]187fn builtin_object_fields_ex(188 obj: ObjValue,189 inc_hidden: bool,190 #[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,191) -> Result<VecVal> {192 #[cfg(feature = "exp-preserve-order")]193 let preserve_order = preserve_order.unwrap_or(false);194 let out = obj.fields_ex(195 inc_hidden,196 #[cfg(feature = "exp-preserve-order")]197 preserve_order,198 );199 Ok(VecVal(Cc::new(200 out.into_iter().map(Val::Str).collect::<Vec<_>>(),201 )))202}203204#[jrsonnet_macros::builtin]205fn builtin_object_has_ex(obj: ObjValue, f: IStr, inc_hidden: bool) -> Result<bool> {206 Ok(obj.has_field_ex(f, inc_hidden))207}208209#[jrsonnet_macros::builtin]210fn builtin_parse_json(st: State, s: IStr) -> Result<Any> {211 use serde_json::Value;212 let value: Value = serde_json::from_str(&s)213 .map_err(|e| RuntimeError(format!("failed to parse json: {}", e).into()))?;214 Ok(Any(Value::into_untyped(value, st)?))215}216217#[jrsonnet_macros::builtin]218fn builtin_parse_yaml(st: State, s: IStr) -> Result<Any> {219 use serde_json::Value;220 let value = serde_yaml::Deserializer::from_str_with_quirks(221 &s,222 DeserializingQuirks { old_octals: true },223 );224 let mut out = vec![];225 for item in value {226 let value = Value::deserialize(item)227 .map_err(|e| RuntimeError(format!("failed to parse yaml: {}", e).into()))?;228 let val = Value::into_untyped(value, st.clone())?;229 out.push(val);230 }231 Ok(Any(if out.is_empty() {232 Val::Null233 } else if out.len() == 1 {234 out.into_iter().next().unwrap()235 } else {236 Val::Arr(out.into())237 }))238}239240#[jrsonnet_macros::builtin]241fn builtin_slice(242 indexable: IndexableVal,243 index: Option<BoundedUsize<0, { i32::MAX as usize }>>,244 end: Option<BoundedUsize<0, { i32::MAX as usize }>>,245 step: Option<BoundedUsize<1, { i32::MAX as usize }>>,246) -> Result<Any> {247 std_slice(indexable, index, end, step).map(Any)248}249250#[jrsonnet_macros::builtin]251fn builtin_substr(str: IStr, from: usize, len: usize) -> Result<String> {252 Ok(str.chars().skip(from as usize).take(len as usize).collect())253}254255#[jrsonnet_macros::builtin]256fn builtin_primitive_equals(a: Any, b: Any) -> Result<bool> {257 primitive_equals(&a.0, &b.0)258}259260#[jrsonnet_macros::builtin]261fn builtin_equals(s: State, a: Any, b: Any) -> Result<bool> {262 equals(s, &a.0, &b.0)263}264265#[jrsonnet_macros::builtin]266fn builtin_modulo(a: f64, b: f64) -> Result<f64> {267 Ok(a % b)268}269270#[jrsonnet_macros::builtin]271fn builtin_mod(s: State, a: Either![f64, IStr], b: Any) -> Result<Any> {272 use Either2::*;273 Ok(Any(evaluate_mod_op(274 s,275 &match a {276 A(v) => Val::Num(v),277 B(s) => Val::Str(s),278 },279 &b.0,280 )?))281}282283#[jrsonnet_macros::builtin]284fn builtin_floor(x: f64) -> Result<f64> {285 Ok(x.floor())286}287288#[jrsonnet_macros::builtin]289fn builtin_ceil(x: f64) -> Result<f64> {290 Ok(x.ceil())291}292293#[jrsonnet_macros::builtin]294fn builtin_log(n: f64) -> Result<f64> {295 Ok(n.ln())296}297298#[jrsonnet_macros::builtin]299fn builtin_pow(x: f64, n: f64) -> Result<f64> {300 Ok(x.powf(n))301}302303#[jrsonnet_macros::builtin]304fn builtin_sqrt(x: PositiveF64) -> Result<f64> {305 Ok(x.0.sqrt())306}307308#[jrsonnet_macros::builtin]309fn builtin_sin(x: f64) -> Result<f64> {310 Ok(x.sin())311}312313#[jrsonnet_macros::builtin]314fn builtin_cos(x: f64) -> Result<f64> {315 Ok(x.cos())316}317318#[jrsonnet_macros::builtin]319fn builtin_tan(x: f64) -> Result<f64> {320 Ok(x.tan())321}322323#[jrsonnet_macros::builtin]324fn builtin_asin(x: f64) -> Result<f64> {325 Ok(x.asin())326}327328#[jrsonnet_macros::builtin]329fn builtin_acos(x: f64) -> Result<f64> {330 Ok(x.acos())331}332333#[jrsonnet_macros::builtin]334fn builtin_atan(x: f64) -> Result<f64> {335 Ok(x.atan())336}337338#[jrsonnet_macros::builtin]339fn builtin_exp(x: f64) -> Result<f64> {340 Ok(x.exp())341}342343fn frexp(s: f64) -> (f64, i16) {344 if 0.0 == s {345 (s, 0)346 } else {347 let lg = s.abs().log2();348 let x = (lg - lg.floor() - 1.0).exp2();349 let exp = lg.floor() + 1.0;350 (s.signum() * x, exp as i16)351 }352}353354#[jrsonnet_macros::builtin]355fn builtin_mantissa(x: f64) -> Result<f64> {356 Ok(frexp(x).0)357}358359#[jrsonnet_macros::builtin]360fn builtin_exponent(x: f64) -> Result<i16> {361 Ok(frexp(x).1)362}363364#[jrsonnet_macros::builtin]365fn builtin_ext_var(s: State, x: IStr) -> Result<Any> {366 Ok(Any(s367 .settings()368 .ext_vars369 .get(&x)370 .cloned()371 .ok_or(UndefinedExternalVariable(x))?))372}373374#[jrsonnet_macros::builtin]375fn builtin_native(s: State, name: IStr) -> Result<FuncVal> {376 Ok(s.settings()377 .ext_natives378 .get(&name)379 .cloned()380 .map(|v| FuncVal::Builtin(v.clone()))381 .ok_or(UndefinedExternalFunction(name))?)382}383384#[jrsonnet_macros::builtin]385fn builtin_filter(s: State, func: FuncVal, arr: ArrValue) -> Result<ArrValue> {386 arr.filter(s.clone(), |val| {387 bool::from_untyped(388 func.evaluate_simple(s.clone(), &[Any(val.clone())].as_slice())?,389 s.clone(),390 )391 })392}393394#[jrsonnet_macros::builtin]395fn builtin_map(s: State, func: FuncVal, arr: ArrValue) -> Result<ArrValue> {396 arr.map(s.clone(), |val| {397 func.evaluate_simple(s.clone(), &[Any(val)].as_slice())398 })399}400401#[jrsonnet_macros::builtin]402fn builtin_flatmap(s: State, func: FuncVal, arr: IndexableVal) -> Result<IndexableVal> {403 match arr {404 IndexableVal::Str(str) => {405 let mut out = String::new();406 for c in str.chars() {407 match func.evaluate_simple(s.clone(), &[c.to_string()].as_slice())? {408 Val::Str(o) => out.push_str(&o),409 _ => throw!(RuntimeError(410 "in std.join all items should be strings".into()411 )),412 };413 }414 Ok(IndexableVal::Str(out.into()))415 }416 IndexableVal::Arr(a) => {417 let mut out = Vec::new();418 for el in a.iter(s.clone()) {419 let el = el?;420 match func.evaluate_simple(s.clone(), &[Any(el)].as_slice())? {421 Val::Arr(o) => {422 for oe in o.iter(s.clone()) {423 out.push(oe?)424 }425 }426 _ => throw!(RuntimeError(427 "in std.join all items should be arrays".into()428 )),429 };430 }431 Ok(IndexableVal::Arr(out.into()))432 }433 }434}435436#[jrsonnet_macros::builtin]437fn builtin_foldl(s: State, func: FuncVal, arr: ArrValue, init: Any) -> Result<Any> {438 let mut acc = init.0;439 for i in arr.iter(s.clone()) {440 acc = func.evaluate_simple(s.clone(), &[Any(acc), Any(i?)].as_slice())?;441 }442 Ok(Any(acc))443}444445#[jrsonnet_macros::builtin]446fn builtin_foldr(s: State, func: FuncVal, arr: ArrValue, init: Any) -> Result<Any> {447 let mut acc = init.0;448 for i in arr.iter(s.clone()).rev() {449 acc = func.evaluate_simple(s.clone(), &[Any(i?), Any(acc)].as_slice())?;450 }451 Ok(Any(acc))452}453454#[jrsonnet_macros::builtin]455#[allow(non_snake_case)]456fn builtin_sort(s: State, arr: ArrValue, keyF: Option<FuncVal>) -> Result<ArrValue> {457 if arr.len() <= 1 {458 return Ok(arr);459 }460 Ok(ArrValue::Eager(sort::sort(461 s.clone(),462 arr.evaluated(s)?,463 keyF.as_ref(),464 )?))465}466467#[jrsonnet_macros::builtin]468fn builtin_format(s: State, str: IStr, vals: Any) -> Result<String> {469 std_format(s, str, vals.0)470}471472#[jrsonnet_macros::builtin]473fn builtin_range(from: i32, to: i32) -> Result<ArrValue> {474 if to < from {475 return Ok(ArrValue::new_eager());476 }477 Ok(ArrValue::new_range(from, to))478}479480#[jrsonnet_macros::builtin]481fn builtin_char(n: u32) -> Result<char> {482 Ok(std::char::from_u32(n as u32).ok_or(InvalidUnicodeCodepointGot(n as u32))?)483}484485#[jrsonnet_macros::builtin]486fn builtin_encode_utf8(str: IStr) -> Result<Bytes> {487 Ok(Bytes(str.bytes().collect::<Vec<u8>>().into()))488}489490#[jrsonnet_macros::builtin]491fn builtin_decode_utf8(arr: Bytes) -> Result<IStr> {492 Ok(std::str::from_utf8(&arr.0)493 .map_err(|_| RuntimeError("bad utf8".into()))?494 .into())495}496497#[jrsonnet_macros::builtin]498fn builtin_md5(str: IStr) -> Result<String> {499 Ok(format!("{:x}", md5::compute(&str.as_bytes())))500}501502#[jrsonnet_macros::builtin]503fn builtin_trace(s: State, loc: CallLocation, str: IStr, rest: Any) -> Result<Any> {504 eprint!("TRACE:");505 if let Some(loc) = loc.0 {506 let locs = s.map_source_locations(&loc.0, &[loc.1]);507 eprint!(508 " {}:{}",509 loc.0.file_name().unwrap().to_str().unwrap(),510 locs[0].line511 );512 }513 eprintln!(" {}", str);514 Ok(rest) as Result<Any>515}516517#[jrsonnet_macros::builtin]518fn builtin_base64(input: Either![Bytes, IStr]) -> Result<String> {519 use Either2::*;520 Ok(match input {521 A(a) => base64::encode(a.0),522 B(l) => base64::encode(l.bytes().collect::<Vec<_>>()),523 })524}525526#[jrsonnet_macros::builtin]527fn builtin_base64_decode_bytes(input: IStr) -> Result<Bytes> {528 Ok(Bytes(529 base64::decode(&input.as_bytes())530 .map_err(|_| RuntimeError("bad base64".into()))?531 .into(),532 ))533}534535#[jrsonnet_macros::builtin]536fn builtin_base64_decode(input: IStr) -> Result<String> {537 let bytes = base64::decode(&input.as_bytes()).map_err(|_| RuntimeError("bad base64".into()))?;538 Ok(String::from_utf8(bytes).map_err(|_| RuntimeError("bad utf8".into()))?)539}540541#[jrsonnet_macros::builtin]542fn builtin_join(s: State, sep: IndexableVal, arr: ArrValue) -> Result<IndexableVal> {543 Ok(match sep {544 IndexableVal::Arr(joiner_items) => {545 let mut out = Vec::new();546547 let mut first = true;548 for item in arr.iter(s.clone()) {549 let item = item?.clone();550 if let Val::Arr(items) = item {551 if !first {552 out.reserve(joiner_items.len());553 554 for item in joiner_items.iter(s.clone()) {555 out.push(item?);556 }557 }558 first = false;559 out.reserve(items.len());560 for item in items.iter(s.clone()) {561 out.push(item?);562 }563 } else {564 throw!(RuntimeError(565 "in std.join all items should be arrays".into()566 ));567 }568 }569570 IndexableVal::Arr(out.into())571 }572 IndexableVal::Str(sep) => {573 let mut out = String::new();574575 let mut first = true;576 for item in arr.iter(s) {577 let item = item?.clone();578 if let Val::Str(item) = item {579 if !first {580 out += &sep;581 }582 first = false;583 out += &item;584 } else {585 throw!(RuntimeError(586 "in std.join all items should be strings".into()587 ));588 }589 }590591 IndexableVal::Str(out.into())592 }593 })594}595596#[jrsonnet_macros::builtin]597fn builtin_escape_string_json(str_: IStr) -> Result<String> {598 Ok(escape_string_json(&str_))599}600601#[jrsonnet_macros::builtin]602fn builtin_manifest_json_ex(603 s: State,604 value: Any,605 indent: IStr,606 newline: Option<IStr>,607 key_val_sep: Option<IStr>,608 #[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,609) -> Result<String> {610 let newline = newline.as_deref().unwrap_or("\n");611 let key_val_sep = key_val_sep.as_deref().unwrap_or(": ");612 manifest_json_ex(613 s,614 &value.0,615 &ManifestJsonOptions {616 padding: &indent,617 mtype: ManifestType::Std,618 newline,619 key_val_sep,620 #[cfg(feature = "exp-preserve-order")]621 preserve_order: preserve_order.unwrap_or(false),622 },623 )624}625626#[jrsonnet_macros::builtin]627fn builtin_manifest_yaml_doc(628 s: State,629 value: Any,630 indent_array_in_object: Option<bool>,631 quote_keys: Option<bool>,632 #[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,633) -> Result<String> {634 manifest_yaml_ex(635 s,636 &value.0,637 &ManifestYamlOptions {638 padding: " ",639 arr_element_padding: if indent_array_in_object.unwrap_or(false) {640 " "641 } else {642 ""643 },644 quote_keys: quote_keys.unwrap_or(true),645 #[cfg(feature = "exp-preserve-order")]646 preserve_order: preserve_order.unwrap_or(false),647 },648 )649}650651#[jrsonnet_macros::builtin]652fn builtin_reverse(value: ArrValue) -> Result<ArrValue> {653 Ok(value.reversed())654}655656#[jrsonnet_macros::builtin]657const fn builtin_id(v: Any) -> Result<Any> {658 Ok(v)659}660661#[jrsonnet_macros::builtin]662fn builtin_str_replace(str: String, from: IStr, to: IStr) -> Result<String> {663 Ok(str.replace(&from as &str, &to as &str))664}665666#[jrsonnet_macros::builtin]667fn builtin_splitlimit(str: IStr, c: IStr, maxsplits: Either![usize, M1]) -> Result<VecVal> {668 use Either2::*;669 Ok(VecVal(Cc::new(match maxsplits {670 A(n) => str671 .splitn(n + 1, &c as &str)672 .map(|s| Val::Str(s.into()))673 .collect(),674 B(_) => str.split(&c as &str).map(|s| Val::Str(s.into())).collect(),675 })))676}677678#[jrsonnet_macros::builtin]679fn builtin_ascii_upper(str: IStr) -> Result<String> {680 Ok(str.to_ascii_uppercase())681}682683#[jrsonnet_macros::builtin]684fn builtin_ascii_lower(str: IStr) -> Result<String> {685 Ok(str.to_ascii_lowercase())686}687688#[jrsonnet_macros::builtin]689fn builtin_member(s: State, arr: IndexableVal, x: Any) -> Result<bool> {690 match arr {691 IndexableVal::Str(str) => {692 let x: IStr = IStr::from_untyped(x.0, s)?;693 Ok(!x.is_empty() && str.contains(&*x))694 }695 IndexableVal::Arr(a) => {696 for item in a.iter(s.clone()) {697 let item = item?;698 if equals(s.clone(), &item, &x.0)? {699 return Ok(true);700 }701 }702 Ok(false)703 }704 }705}706707#[jrsonnet_macros::builtin]708fn builtin_count(s: State, arr: Vec<Any>, v: Any) -> Result<usize> {709 let mut count = 0;710 for item in arr.iter() {711 if equals(s.clone(), &item.0, &v.0)? {712 count += 1;713 }714 }715 Ok(count)716}717718#[jrsonnet_macros::builtin]719fn builtin_any(s: State, arr: ArrValue) -> Result<bool> {720 for v in arr.iter(s.clone()) {721 let v = bool::from_untyped(v?, s.clone())?;722 if v {723 return Ok(true);724 }725 }726 Ok(false)727}728729#[jrsonnet_macros::builtin]730fn builtin_all(s: State, arr: ArrValue) -> Result<bool> {731 for v in arr.iter(s.clone()) {732 let v = bool::from_untyped(v?, s.clone())?;733 if !v {734 return Ok(false);735 }736 }737 Ok(true)738}