difftreelog
refactor(stdlib) implement as a standalone crate
in: master
New builtins system allows to split standard library to standalone crate
16 files changed
crates/jrsonnet-stdlib/Cargo.tomldiffbeforeafterboth--- a/crates/jrsonnet-stdlib/Cargo.toml
+++ b/crates/jrsonnet-stdlib/Cargo.toml
@@ -7,5 +7,46 @@
edition = "2021"
[features]
+default = []
+# Serializes standard library AST, and deserialize on start, instead of parsing it every run from text
+serialized-stdlib = ["bincode", "jrsonnet-parser/serde"]
+# Enables legacy `std.thisFile` support, at the cost of worse caching
+legacy-this-file = []
+# Add order preservation flag to some functions
+exp-preserve-order = ["jrsonnet-evaluator/exp-preserve-order"]
+# Preserve order for files parsed via `std.parseJson`
+# Shame it isn't possible to enable per parse call, instead of globally
+exp-serde-preserve-order = [
+ "serde_json/preserve_order",
+ "jrsonnet-evaluator/exp-serde-preserve-order",
+]
[dependencies]
+jrsonnet-evaluator = { path = "../jrsonnet-evaluator", features = [
+ # std.parseJson parses file via serde, then converts Value to evaluator Val
+ "serde_json",
+], version = "0.4.2" }
+jrsonnet-macros = { path = "../jrsonnet-macros", version = "0.4.2" }
+jrsonnet-parser = { path = "../jrsonnet-parser", version = "0.4.2" }
+jrsonnet-gcmodule = "0.3.4"
+
+# Used for stdlib AST serialization
+bincode = { version = "1.3", optional = true }
+# Used both for stdlib AST serialization and std.parseJson/std.parseYaml
+serde = "1.0"
+
+# std.md5
+md5 = "0.7.0"
+# std.base64
+base64 = "0.13.0"
+# std.parseJson
+serde_json = "1.0"
+# std.parseYaml, custom library fork is used for C++/golang compatibility
+serde_yaml_with_quirks = "0.8.24"
+
+[build-dependencies]
+jrsonnet-parser = { path = "../jrsonnet-parser", version = "0.4.2", features = [
+ "serde",
+] }
+serde = "1.0"
+bincode = "1.3"
crates/jrsonnet-stdlib/README.mddiffbeforeafterboth--- a/crates/jrsonnet-stdlib/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# jrsonnet-stdlib
-
-Jsonnet standard library packaged as crate
crates/jrsonnet-stdlib/build.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-stdlib/build.rs
@@ -0,0 +1,21 @@
+use std::{borrow::Cow, env, fs::File, io::Write, path::Path};
+
+use bincode::serialize;
+use jrsonnet_parser::{parse, ParserSettings, Source};
+
+fn main() {
+ let parsed = parse(
+ include_str!("./src/std.jsonnet"),
+ &ParserSettings {
+ file_name: Source::new_virtual(Cow::Borrowed("<std>")),
+ },
+ )
+ .expect("parse");
+
+ {
+ let out_dir = env::var("OUT_DIR").unwrap();
+ let dest_path = Path::new(&out_dir).join("stdlib.bincode");
+ let mut f = File::create(&dest_path).unwrap();
+ f.write_all(&serialize(&parsed).unwrap()).unwrap();
+ }
+}
crates/jrsonnet-stdlib/src/arrays.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-stdlib/src/arrays.rs
@@ -0,0 +1,216 @@
+use jrsonnet_evaluator::{
+ error::Result,
+ function::{builtin, FuncVal},
+ throw_runtime,
+ typed::{Any, BoundedUsize, Typed, VecVal},
+ val::{equals, ArrValue, IndexableVal},
+ IStr, State, Val,
+};
+use jrsonnet_gcmodule::Cc;
+
+#[builtin]
+pub fn builtin_make_array(s: State, sz: usize, func: FuncVal) -> Result<VecVal> {
+ let mut out = Vec::with_capacity(sz);
+ for i in 0..sz {
+ out.push(func.evaluate_simple(s.clone(), &(i as f64,))?);
+ }
+ Ok(VecVal(Cc::new(out)))
+}
+
+#[builtin]
+pub fn builtin_slice(
+ indexable: IndexableVal,
+ index: Option<BoundedUsize<0, { i32::MAX as usize }>>,
+ end: Option<BoundedUsize<0, { i32::MAX as usize }>>,
+ step: Option<BoundedUsize<1, { i32::MAX as usize }>>,
+) -> Result<Any> {
+ indexable.slice(index, end, step).map(Val::from).map(Any)
+}
+
+#[builtin]
+pub fn builtin_map(s: State, func: FuncVal, arr: ArrValue) -> Result<ArrValue> {
+ arr.map(s.clone(), |val| {
+ func.evaluate_simple(s.clone(), &(Any(val),))
+ })
+}
+
+#[builtin]
+pub fn builtin_flatmap(s: State, func: FuncVal, arr: IndexableVal) -> Result<IndexableVal> {
+ match arr {
+ IndexableVal::Str(str) => {
+ let mut out = String::new();
+ for c in str.chars() {
+ match func.evaluate_simple(s.clone(), &(c.to_string(),))? {
+ Val::Str(o) => out.push_str(&o),
+ Val::Null => continue,
+ _ => throw_runtime!("in std.join all items should be strings"),
+ };
+ }
+ Ok(IndexableVal::Str(out.into()))
+ }
+ IndexableVal::Arr(a) => {
+ let mut out = Vec::new();
+ for el in a.iter(s.clone()) {
+ let el = el?;
+ match func.evaluate_simple(s.clone(), &(Any(el),))? {
+ Val::Arr(o) => {
+ for oe in o.iter(s.clone()) {
+ out.push(oe?);
+ }
+ }
+ Val::Null => continue,
+ _ => throw_runtime!("in std.join all items should be arrays"),
+ };
+ }
+ Ok(IndexableVal::Arr(out.into()))
+ }
+ }
+}
+
+#[builtin]
+pub fn builtin_filter(s: State, func: FuncVal, arr: ArrValue) -> Result<ArrValue> {
+ arr.filter(s.clone(), |val| {
+ bool::from_untyped(
+ func.evaluate_simple(s.clone(), &(Any(val.clone()),))?,
+ s.clone(),
+ )
+ })
+}
+
+#[builtin]
+pub fn builtin_foldl(s: State, func: FuncVal, arr: ArrValue, init: Any) -> Result<Any> {
+ let mut acc = init.0;
+ for i in arr.iter(s.clone()) {
+ acc = func.evaluate_simple(s.clone(), &(Any(acc), Any(i?)))?;
+ }
+ Ok(Any(acc))
+}
+
+#[builtin]
+pub fn builtin_foldr(s: State, func: FuncVal, arr: ArrValue, init: Any) -> Result<Any> {
+ let mut acc = init.0;
+ for i in arr.iter(s.clone()).rev() {
+ acc = func.evaluate_simple(s.clone(), &(Any(i?), Any(acc)))?;
+ }
+ Ok(Any(acc))
+}
+
+#[builtin]
+pub fn builtin_range(from: i32, to: i32) -> Result<ArrValue> {
+ if to < from {
+ return Ok(ArrValue::new_eager());
+ }
+ Ok(ArrValue::new_range(from, to))
+}
+
+#[builtin]
+pub fn builtin_join(s: State, sep: IndexableVal, arr: ArrValue) -> Result<IndexableVal> {
+ Ok(match sep {
+ IndexableVal::Arr(joiner_items) => {
+ let mut out = Vec::new();
+
+ let mut first = true;
+ for item in arr.iter(s.clone()) {
+ let item = item?.clone();
+ if let Val::Arr(items) = item {
+ if !first {
+ out.reserve(joiner_items.len());
+ // TODO: extend
+ for item in joiner_items.iter(s.clone()) {
+ out.push(item?);
+ }
+ }
+ first = false;
+ out.reserve(items.len());
+ for item in items.iter(s.clone()) {
+ out.push(item?);
+ }
+ } else if matches!(item, Val::Null) {
+ continue;
+ } else {
+ throw_runtime!("in std.join all items should be arrays");
+ }
+ }
+
+ IndexableVal::Arr(out.into())
+ }
+ IndexableVal::Str(sep) => {
+ let mut out = String::new();
+
+ let mut first = true;
+ for item in arr.iter(s) {
+ let item = item?.clone();
+ if let Val::Str(item) = item {
+ if !first {
+ out += &sep;
+ }
+ first = false;
+ out += &item;
+ } else if matches!(item, Val::Null) {
+ continue;
+ } else {
+ throw_runtime!("in std.join all items should be strings");
+ }
+ }
+
+ IndexableVal::Str(out.into())
+ }
+ })
+}
+
+#[builtin]
+pub fn builtin_reverse(value: ArrValue) -> Result<ArrValue> {
+ Ok(value.reversed())
+}
+
+#[builtin]
+pub fn builtin_any(s: State, arr: ArrValue) -> Result<bool> {
+ for v in arr.iter(s.clone()) {
+ let v = bool::from_untyped(v?, s.clone())?;
+ if v {
+ return Ok(true);
+ }
+ }
+ Ok(false)
+}
+
+#[builtin]
+pub fn builtin_all(s: State, arr: ArrValue) -> Result<bool> {
+ for v in arr.iter(s.clone()) {
+ let v = bool::from_untyped(v?, s.clone())?;
+ if !v {
+ return Ok(false);
+ }
+ }
+ Ok(true)
+}
+
+#[builtin]
+pub fn builtin_member(s: State, arr: IndexableVal, x: Any) -> Result<bool> {
+ match arr {
+ IndexableVal::Str(str) => {
+ let x: IStr = IStr::from_untyped(x.0, s)?;
+ Ok(!x.is_empty() && str.contains(&*x))
+ }
+ IndexableVal::Arr(a) => {
+ for item in a.iter(s.clone()) {
+ let item = item?;
+ if equals(s.clone(), &item, &x.0)? {
+ return Ok(true);
+ }
+ }
+ Ok(false)
+ }
+ }
+}
+
+#[builtin]
+pub fn builtin_count(s: State, arr: Vec<Any>, v: Any) -> Result<usize> {
+ let mut count = 0;
+ for item in &arr {
+ if equals(s.clone(), &item.0, &v.0)? {
+ count += 1;
+ }
+ }
+ Ok(count)
+}
crates/jrsonnet-stdlib/src/encoding.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-stdlib/src/encoding.rs
@@ -0,0 +1,41 @@
+use jrsonnet_evaluator::{
+ error::{Error::RuntimeError, Result},
+ function::builtin,
+ typed::{Either, Either2},
+ IBytes, IStr,
+};
+
+#[builtin]
+pub fn builtin_encode_utf8(str: IStr) -> Result<IBytes> {
+ Ok(str.cast_bytes())
+}
+
+#[builtin]
+pub fn builtin_decode_utf8(arr: IBytes) -> Result<IStr> {
+ Ok(arr
+ .cast_str()
+ .ok_or_else(|| RuntimeError("bad utf8".into()))?)
+}
+
+#[builtin]
+pub fn builtin_base64(input: Either![IBytes, IStr]) -> Result<String> {
+ use Either2::*;
+ Ok(match input {
+ A(a) => base64::encode(a.as_slice()),
+ B(l) => base64::encode(l.bytes().collect::<Vec<_>>()),
+ })
+}
+
+#[builtin]
+pub fn builtin_base64_decode_bytes(input: IStr) -> Result<IBytes> {
+ Ok(base64::decode(&input.as_bytes())
+ .map_err(|_| RuntimeError("bad base64".into()))?
+ .as_slice()
+ .into())
+}
+
+#[builtin]
+pub fn builtin_base64_decode(input: IStr) -> Result<String> {
+ let bytes = base64::decode(&input.as_bytes()).map_err(|_| RuntimeError("bad base64".into()))?;
+ Ok(String::from_utf8(bytes).map_err(|_| RuntimeError("bad utf8".into()))?)
+}
crates/jrsonnet-stdlib/src/expr.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-stdlib/src/expr.rs
@@ -0,0 +1,22 @@
+use std::borrow::Cow;
+
+use jrsonnet_parser::{LocExpr, ParserSettings, Source};
+
+pub const STDLIB_STR: &str = include_str!("./std.jsonnet");
+
+pub fn stdlib_expr() -> LocExpr {
+ #[cfg(feature = "serialized-stdlib")]
+ {
+ // Should not panic, stdlib.bincode is generated in build.rs
+ return bincode::deserialize(include_bytes!(concat!(env!("OUT_DIR"), "/stdlib.bincode")))
+ .unwrap();
+ }
+
+ jrsonnet_parser::parse(
+ STDLIB_STR,
+ &ParserSettings {
+ file_name: Source::new_virtual(Cow::Borrowed("<std>")),
+ },
+ )
+ .unwrap()
+}
crates/jrsonnet-stdlib/src/hash.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-stdlib/src/hash.rs
@@ -0,0 +1,6 @@
+use jrsonnet_evaluator::{error::Result, function::builtin, IStr};
+
+#[builtin]
+pub fn builtin_md5(str: IStr) -> Result<String> {
+ Ok(format!("{:x}", md5::compute(&str.as_bytes())))
+}
crates/jrsonnet-stdlib/src/lib.rsdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/lib.rs
+++ b/crates/jrsonnet-stdlib/src/lib.rs
@@ -1 +1,420 @@
-pub const STDLIB_STR: &str = include_str!("./std.jsonnet");
+use std::{
+ borrow::Cow,
+ cell::{Ref, RefCell, RefMut},
+ collections::HashMap,
+ rc::Rc,
+};
+
+use jrsonnet_evaluator::{
+ error::{Error::*, Result},
+ function::{builtin::Builtin, ArgLike, CallLocation, FuncVal, TlaArg},
+ gc::TraceBox,
+ tb,
+ typed::{Any, Either, Either2, Either4, VecVal, M1},
+ val::ArrValue,
+ Context, ContextBuilder, IStr, ObjValue, ObjValueBuilder, State, Thunk, Val,
+};
+use jrsonnet_gcmodule::Cc;
+use jrsonnet_macros::builtin;
+use jrsonnet_parser::Source;
+
+mod expr;
+mod types;
+pub use types::*;
+mod arrays;
+pub use arrays::*;
+mod math;
+pub use math::*;
+mod operator;
+pub use operator::*;
+mod sort;
+pub use sort::*;
+mod hash;
+pub use hash::*;
+mod encoding;
+pub use encoding::*;
+mod objects;
+pub use objects::*;
+mod manifest;
+pub use manifest::*;
+mod parse;
+pub use parse::*;
+
+pub fn stdlib_uncached(s: State, settings: Rc<RefCell<Settings>>) -> ObjValue {
+ let mut builder = ObjValueBuilder::new();
+
+ let expr = expr::stdlib_expr();
+ let eval = jrsonnet_evaluator::evaluate(s.clone(), Context::default(), &expr)
+ .expect("stdlib.jsonnet should have no errors")
+ .as_obj()
+ .expect("stdlib.jsonnet should evaluate to object");
+
+ builder.with_super(eval);
+
+ for (name, builtin) in [
+ ("length".into(), builtin_length::INST),
+ // Types
+ ("type".into(), builtin_type::INST),
+ ("isString".into(), builtin_is_string::INST),
+ ("isNumber".into(), builtin_is_number::INST),
+ ("isBoolean".into(), builtin_is_boolean::INST),
+ ("isObject".into(), builtin_is_object::INST),
+ ("isArray".into(), builtin_is_array::INST),
+ ("isFunction".into(), builtin_is_function::INST),
+ // Arrays
+ ("makeArray".into(), builtin_make_array::INST),
+ ("slice".into(), builtin_slice::INST),
+ ("map".into(), builtin_map::INST),
+ ("flatMap".into(), builtin_flatmap::INST),
+ ("filter".into(), builtin_filter::INST),
+ ("foldl".into(), builtin_foldl::INST),
+ ("foldr".into(), builtin_foldr::INST),
+ ("range".into(), builtin_range::INST),
+ ("join".into(), builtin_join::INST),
+ ("reverse".into(), builtin_reverse::INST),
+ ("any".into(), builtin_any::INST),
+ ("all".into(), builtin_all::INST),
+ ("member".into(), builtin_member::INST),
+ ("count".into(), builtin_count::INST),
+ // Math
+ ("modulo".into(), builtin_modulo::INST),
+ ("floor".into(), builtin_floor::INST),
+ ("ceil".into(), builtin_ceil::INST),
+ ("log".into(), builtin_log::INST),
+ ("pow".into(), builtin_pow::INST),
+ ("sqrt".into(), builtin_sqrt::INST),
+ ("sin".into(), builtin_sin::INST),
+ ("cos".into(), builtin_cos::INST),
+ ("tan".into(), builtin_tan::INST),
+ ("asin".into(), builtin_asin::INST),
+ ("acos".into(), builtin_acos::INST),
+ ("atan".into(), builtin_atan::INST),
+ ("exp".into(), builtin_exp::INST),
+ ("mantissa".into(), builtin_mantissa::INST),
+ ("exponent".into(), builtin_exponent::INST),
+ // Operator
+ ("mod".into(), builtin_mod::INST),
+ ("primitiveEquals".into(), builtin_primitive_equals::INST),
+ ("equals".into(), builtin_equals::INST),
+ ("format".into(), builtin_format::INST),
+ // Sort
+ ("sort".into(), builtin_sort::INST),
+ // Hash
+ ("md5".into(), builtin_md5::INST),
+ // Encoding
+ ("encodeUTF8".into(), builtin_encode_utf8::INST),
+ ("decodeUTF8".into(), builtin_decode_utf8::INST),
+ ("base64".into(), builtin_base64::INST),
+ ("base64Decode".into(), builtin_base64_decode::INST),
+ (
+ "base64DecodeBytes".into(),
+ builtin_base64_decode_bytes::INST,
+ ),
+ // Objects
+ ("objectFieldsEx".into(), builtin_object_fields_ex::INST),
+ ("objectHasEx".into(), builtin_object_has_ex::INST),
+ // Manifest
+ ("escapeStringJson".into(), builtin_escape_string_json::INST),
+ ("manifestJsonEx".into(), builtin_manifest_json_ex::INST),
+ ("manifestYamlDoc".into(), builtin_manifest_yaml_doc::INST),
+ // Parsing
+ ("parseJson".into(), builtin_parse_json::INST),
+ ("parseYaml".into(), builtin_parse_yaml::INST),
+ // Misc
+ ("codepoint".into(), builtin_codepoint::INST),
+ ("substr".into(), builtin_substr::INST),
+ ("char".into(), builtin_char::INST),
+ ("strReplace".into(), builtin_str_replace::INST),
+ ("splitLimit".into(), builtin_splitlimit::INST),
+ ("asciiUpper".into(), builtin_ascii_upper::INST),
+ ("asciiLower".into(), builtin_ascii_lower::INST),
+ ]
+ .iter()
+ .cloned()
+ {
+ builder
+ .member(name)
+ .hide()
+ .value(s.clone(), Val::Func(FuncVal::StaticBuiltin(builtin)))
+ .expect("no conflict");
+ }
+
+ builder
+ .member("extVar".into())
+ .hide()
+ .value(
+ s.clone(),
+ Val::Func(FuncVal::Builtin(Cc::new(tb!(builtin_ext_var {
+ settings: settings.clone()
+ })))),
+ )
+ .expect("no conflict");
+ builder
+ .member("native".into())
+ .hide()
+ .value(
+ s.clone(),
+ Val::Func(FuncVal::Builtin(Cc::new(tb!(builtin_native {
+ settings: settings.clone()
+ })))),
+ )
+ .expect("no conflict");
+ builder
+ .member("trace".into())
+ .hide()
+ .value(
+ s.clone(),
+ Val::Func(FuncVal::Builtin(Cc::new(tb!(builtin_trace { settings })))),
+ )
+ .expect("no conflict");
+
+ builder
+ .member("id".into())
+ .hide()
+ .value(s, Val::Func(FuncVal::Id))
+ .expect("no conflict");
+
+ builder.build()
+}
+
+pub trait TracePrinter {
+ fn print_trace(&self, s: State, loc: CallLocation, value: IStr);
+}
+
+pub struct StdTracePrinter;
+impl TracePrinter for StdTracePrinter {
+ fn print_trace(&self, s: State, loc: CallLocation, value: IStr) {
+ eprint!("TRACE:");
+ if let Some(loc) = loc.0 {
+ let locs = s.map_source_locations(loc.0.clone(), &[loc.1]);
+ eprint!(" {}:{}", loc.0.short_display(), locs[0].line);
+ }
+ eprintln!(" {}", value);
+ }
+}
+
+pub struct Settings {
+ /// Used for `std.extVar`
+ pub ext_vars: HashMap<IStr, TlaArg>,
+ /// Used for `std.native`
+ pub ext_natives: HashMap<IStr, Cc<TraceBox<dyn Builtin>>>,
+ /// Used for `std.trace`
+ pub trace_printer: Box<dyn TracePrinter>,
+}
+
+impl Default for Settings {
+ fn default() -> Self {
+ Self {
+ ext_vars: Default::default(),
+ ext_natives: Default::default(),
+ trace_printer: Box::new(StdTracePrinter),
+ }
+ }
+}
+
+pub fn extvar_source(name: &str) -> Source {
+ let source_name = format!("<extvar:{}>", name);
+ Source::new_virtual(Cow::Owned(source_name))
+}
+
+pub struct ContextInitializer {
+ // When we don't need to support legacy-this-file, we can reuse same context for all files
+ #[cfg(not(feature = "legacy-this-file"))]
+ context: Context,
+ // Otherwise, we can only keep first stdlib layer, and then stack thisFile on top of it
+ #[cfg(feature = "legacy-this-file")]
+ stdlib_obj: ObjValue,
+ settings: Rc<RefCell<Settings>>,
+}
+impl ContextInitializer {
+ pub fn new(s: State) -> Self {
+ let settings = Rc::new(RefCell::new(Settings::default()));
+ Self {
+ #[cfg(not(feature = "legacy-this-file"))]
+ context: {
+ let mut context = ContextBuilder::with_capacity(1);
+ context.bind(
+ "std".into(),
+ Thunk::evaluated(Val::Obj(stdlib_uncached(s, settings.clone()))),
+ );
+ context.build()
+ },
+ #[cfg(feature = "legacy-this-file")]
+ stdlib_obj: stdlib_uncached(s, settings.clone()),
+ settings,
+ }
+ }
+ pub fn settings(&self) -> Ref<Settings> {
+ self.settings.borrow()
+ }
+ pub fn settings_mut(&self) -> RefMut<Settings> {
+ self.settings.borrow_mut()
+ }
+ pub fn add_ext_var(&self, name: IStr, value: Val) {
+ self.settings_mut()
+ .ext_vars
+ .insert(name, TlaArg::Val(value));
+ }
+ pub fn add_ext_str(&self, name: IStr, value: IStr) {
+ self.settings_mut()
+ .ext_vars
+ .insert(name, TlaArg::String(value));
+ }
+ pub fn add_ext_code(&self, name: &str, code: String) -> Result<()> {
+ let source = extvar_source(name);
+ let parsed = jrsonnet_parser::parse(
+ &code,
+ &jrsonnet_parser::ParserSettings {
+ file_name: source.clone(),
+ },
+ )
+ .map_err(|e| ImportSyntaxError {
+ path: source,
+ source_code: code.clone().into(),
+ error: Box::new(e),
+ })?;
+ // self.data_mut().volatile_files.insert(source_name, code);
+ self.settings_mut()
+ .ext_vars
+ .insert(name.into(), TlaArg::Code(parsed));
+ Ok(())
+ }
+ pub fn add_native(&self, name: IStr, cb: Cc<TraceBox<dyn Builtin>>) {
+ self.settings_mut().ext_natives.insert(name, cb);
+ }
+}
+impl jrsonnet_evaluator::ContextInitializer for ContextInitializer {
+ #[cfg(not(feature = "legacy-this-file"))]
+ fn initialize(&self, _s: State, _source: Source) -> jrsonnet_evaluator::Context {
+ self.context.clone()
+ }
+ #[cfg(feature = "legacy-this-file")]
+ fn initialize(&self, s: State, source: Source) -> jrsonnet_evaluator::Context {
+ let mut builder = ObjValueBuilder::new();
+ builder.with_super(self.stdlib_obj.clone());
+ builder
+ .member("thisFile".into())
+ .hide()
+ .value(
+ s,
+ Val::Str(match source.repr() {
+ Ok(p) => p.display().to_string().into(),
+ // Virtual files end up as empty strings in std.thisFile
+ Err(_e) => "".into(),
+ }),
+ )
+ .expect("this object builder is empty");
+ let stdlib_with_this_file = builder.build();
+
+ let mut context = ContextBuilder::with_capacity(1);
+ context.bind(
+ "std".into(),
+ Thunk::evaluated(Val::Obj(stdlib_with_this_file)),
+ );
+ context.build()
+ }
+ unsafe fn as_any(&self) -> &dyn std::any::Any {
+ self
+ }
+}
+
+#[builtin]
+fn builtin_length(x: Either![IStr, ArrValue, ObjValue, FuncVal]) -> Result<usize> {
+ use Either4::*;
+ Ok(match x {
+ A(x) => x.chars().count(),
+ B(x) => x.len(),
+ C(x) => x.len(),
+ D(f) => f.params_len(),
+ })
+}
+
+#[builtin]
+const fn builtin_codepoint(str: char) -> Result<u32> {
+ Ok(str as u32)
+}
+
+#[builtin]
+fn builtin_substr(str: IStr, from: usize, len: usize) -> Result<String> {
+ Ok(str.chars().skip(from as usize).take(len as usize).collect())
+}
+
+#[builtin(fields(
+ settings: Rc<RefCell<Settings>>,
+))]
+fn builtin_ext_var(this: &builtin_ext_var, s: State, x: IStr) -> Result<Any> {
+ let ctx = s.create_default_context(extvar_source(&x));
+ Ok(Any(this
+ .settings
+ .borrow()
+ .ext_vars
+ .get(&x)
+ .cloned()
+ .ok_or(UndefinedExternalVariable(x))?
+ .evaluate_arg(s.clone(), ctx, true)?
+ .evaluate(s)?))
+}
+
+#[builtin(fields(
+ settings: Rc<RefCell<Settings>>,
+))]
+fn builtin_native(this: &builtin_native, name: IStr) -> Result<Any> {
+ Ok(Any(this
+ .settings
+ .borrow()
+ .ext_natives
+ .get(&name)
+ .cloned()
+ .map_or(Val::Null, |v| {
+ Val::Func(FuncVal::Builtin(v.clone()))
+ })))
+}
+
+#[builtin]
+fn builtin_char(n: u32) -> Result<char> {
+ Ok(std::char::from_u32(n as u32).ok_or(InvalidUnicodeCodepointGot(n as u32))?)
+}
+
+#[builtin(fields(
+ settings: Rc<RefCell<Settings>>,
+))]
+fn builtin_trace(
+ this: &builtin_trace,
+ s: State,
+ loc: CallLocation,
+ str: IStr,
+ rest: Any,
+) -> Result<Any> {
+ this.settings
+ .borrow()
+ .trace_printer
+ .print_trace(s, loc, str);
+ Ok(rest) as Result<Any>
+}
+
+#[builtin]
+fn builtin_str_replace(str: String, from: IStr, to: IStr) -> Result<String> {
+ Ok(str.replace(&from as &str, &to as &str))
+}
+
+#[builtin]
+fn builtin_splitlimit(str: IStr, c: IStr, maxsplits: Either![usize, M1]) -> Result<VecVal> {
+ use Either2::*;
+ Ok(VecVal(Cc::new(match maxsplits {
+ A(n) => str
+ .splitn(n + 1, &c as &str)
+ .map(|s| Val::Str(s.into()))
+ .collect(),
+ B(_) => str.split(&c as &str).map(|s| Val::Str(s.into())).collect(),
+ })))
+}
+
+#[builtin]
+fn builtin_ascii_upper(str: IStr) -> Result<String> {
+ Ok(str.to_ascii_uppercase())
+}
+
+#[builtin]
+fn builtin_ascii_lower(str: IStr) -> Result<String> {
+ Ok(str.to_ascii_lowercase())
+}
crates/jrsonnet-stdlib/src/manifest.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-stdlib/src/manifest.rs
@@ -0,0 +1,65 @@
+use jrsonnet_evaluator::{
+ error::Result,
+ function::builtin,
+ stdlib::manifest::{
+ escape_string_json, manifest_json_ex, manifest_yaml_ex, ManifestJsonOptions, ManifestType,
+ ManifestYamlOptions,
+ },
+ typed::Any,
+ IStr, State,
+};
+
+#[builtin]
+pub fn builtin_escape_string_json(str_: IStr) -> Result<String> {
+ Ok(escape_string_json(&str_))
+}
+
+#[builtin]
+pub fn builtin_manifest_json_ex(
+ s: State,
+ value: Any,
+ indent: IStr,
+ newline: Option<IStr>,
+ key_val_sep: Option<IStr>,
+ #[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,
+) -> Result<String> {
+ let newline = newline.as_deref().unwrap_or("\n");
+ let key_val_sep = key_val_sep.as_deref().unwrap_or(": ");
+ manifest_json_ex(
+ s,
+ &value.0,
+ &ManifestJsonOptions {
+ padding: &indent,
+ mtype: ManifestType::Std,
+ newline,
+ key_val_sep,
+ #[cfg(feature = "exp-preserve-order")]
+ preserve_order: preserve_order.unwrap_or(false),
+ },
+ )
+}
+
+#[builtin]
+pub fn builtin_manifest_yaml_doc(
+ s: State,
+ value: Any,
+ indent_array_in_object: Option<bool>,
+ quote_keys: Option<bool>,
+ #[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,
+) -> Result<String> {
+ manifest_yaml_ex(
+ s,
+ &value.0,
+ &ManifestYamlOptions {
+ padding: " ",
+ arr_element_padding: if indent_array_in_object.unwrap_or(false) {
+ " "
+ } else {
+ ""
+ },
+ quote_keys: quote_keys.unwrap_or(true),
+ #[cfg(feature = "exp-preserve-order")]
+ preserve_order: preserve_order.unwrap_or(false),
+ },
+ )
+}
crates/jrsonnet-stdlib/src/math.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-stdlib/src/math.rs
@@ -0,0 +1,87 @@
+use jrsonnet_evaluator::{error::Result, function::builtin, typed::PositiveF64};
+
+#[builtin]
+pub fn builtin_modulo(a: f64, b: f64) -> Result<f64> {
+ Ok(a % b)
+}
+
+#[builtin]
+pub fn builtin_floor(x: f64) -> Result<f64> {
+ Ok(x.floor())
+}
+
+#[builtin]
+pub fn builtin_ceil(x: f64) -> Result<f64> {
+ Ok(x.ceil())
+}
+
+#[builtin]
+pub fn builtin_log(n: f64) -> Result<f64> {
+ Ok(n.ln())
+}
+
+#[builtin]
+pub fn builtin_pow(x: f64, n: f64) -> Result<f64> {
+ Ok(x.powf(n))
+}
+
+#[builtin]
+pub fn builtin_sqrt(x: PositiveF64) -> Result<f64> {
+ Ok(x.0.sqrt())
+}
+
+#[builtin]
+pub fn builtin_sin(x: f64) -> Result<f64> {
+ Ok(x.sin())
+}
+
+#[builtin]
+pub fn builtin_cos(x: f64) -> Result<f64> {
+ Ok(x.cos())
+}
+
+#[builtin]
+pub fn builtin_tan(x: f64) -> Result<f64> {
+ Ok(x.tan())
+}
+
+#[builtin]
+pub fn builtin_asin(x: f64) -> Result<f64> {
+ Ok(x.asin())
+}
+
+#[builtin]
+pub fn builtin_acos(x: f64) -> Result<f64> {
+ Ok(x.acos())
+}
+
+#[builtin]
+pub fn builtin_atan(x: f64) -> Result<f64> {
+ Ok(x.atan())
+}
+
+#[builtin]
+pub fn builtin_exp(x: f64) -> Result<f64> {
+ Ok(x.exp())
+}
+
+fn frexp(s: f64) -> (f64, i16) {
+ if 0.0 == s {
+ (s, 0)
+ } else {
+ let lg = s.abs().log2();
+ let x = (lg - lg.floor() - 1.0).exp2();
+ let exp = lg.floor() + 1.0;
+ (s.signum() * x, exp as i16)
+ }
+}
+
+#[builtin]
+pub fn builtin_mantissa(x: f64) -> Result<f64> {
+ Ok(frexp(x).0)
+}
+
+#[builtin]
+pub fn builtin_exponent(x: f64) -> Result<i16> {
+ Ok(frexp(x).1)
+}
crates/jrsonnet-stdlib/src/objects.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-stdlib/src/objects.rs
@@ -0,0 +1,27 @@
+use jrsonnet_evaluator::{
+ error::Result, function::builtin, typed::VecVal, val::Val, IStr, ObjValue,
+};
+use jrsonnet_gcmodule::Cc;
+
+#[builtin]
+pub fn builtin_object_fields_ex(
+ obj: ObjValue,
+ inc_hidden: bool,
+ #[cfg(feature = "exp-preserve-order")] preserve_order: Option<bool>,
+) -> Result<VecVal> {
+ #[cfg(feature = "exp-preserve-order")]
+ let preserve_order = preserve_order.unwrap_or(false);
+ let out = obj.fields_ex(
+ inc_hidden,
+ #[cfg(feature = "exp-preserve-order")]
+ preserve_order,
+ );
+ Ok(VecVal(Cc::new(
+ out.into_iter().map(Val::Str).collect::<Vec<_>>(),
+ )))
+}
+
+#[builtin]
+pub fn builtin_object_has_ex(obj: ObjValue, f: IStr, inc_hidden: bool) -> Result<bool> {
+ Ok(obj.has_field_ex(f, inc_hidden))
+}
crates/jrsonnet-stdlib/src/operator.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-stdlib/src/operator.rs
@@ -0,0 +1,40 @@
+//! Some jsonnet operations are desugared to stdlib functions...
+//! However, in our case we instead implement them in native, and implement native functions on top of core for backwards compatibility
+
+use jrsonnet_evaluator::{
+ error::Result,
+ function::builtin,
+ operator::evaluate_mod_op,
+ stdlib::std_format,
+ typed::{Any, Either, Either2},
+ val::{equals, primitive_equals},
+ IStr, State, Val,
+};
+
+#[builtin]
+pub fn builtin_mod(s: State, a: Either![f64, IStr], b: Any) -> Result<Any> {
+ use Either2::*;
+ Ok(Any(evaluate_mod_op(
+ s,
+ &match a {
+ A(v) => Val::Num(v),
+ B(s) => Val::Str(s),
+ },
+ &b.0,
+ )?))
+}
+
+#[builtin]
+pub fn builtin_primitive_equals(a: Any, b: Any) -> Result<bool> {
+ primitive_equals(&a.0, &b.0)
+}
+
+#[builtin]
+pub fn builtin_equals(s: State, a: Any, b: Any) -> Result<bool> {
+ equals(s, &a.0, &b.0)
+}
+
+#[builtin]
+pub fn builtin_format(s: State, str: IStr, vals: Any) -> Result<String> {
+ std_format(s, str, vals.0)
+}
crates/jrsonnet-stdlib/src/parse.rsdiffbeforeafterbothno content
crates/jrsonnet-stdlib/src/sort.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-stdlib/src/sort.rs
@@ -0,0 +1,109 @@
+use jrsonnet_evaluator::{
+ error::Result,
+ function::{builtin, FuncVal},
+ throw_runtime,
+ typed::Any,
+ val::ArrValue,
+ State, Val,
+};
+use jrsonnet_gcmodule::Cc;
+
+#[derive(Copy, Clone)]
+enum SortKeyType {
+ Number,
+ String,
+ Unknown,
+}
+
+#[derive(PartialEq)]
+struct NonNaNf64(f64);
+impl PartialOrd for NonNaNf64 {
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ self.0.partial_cmp(&other.0)
+ }
+}
+impl Eq for NonNaNf64 {}
+impl Ord for NonNaNf64 {
+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+ self.partial_cmp(other).expect("non nan")
+ }
+}
+
+fn get_sort_type<T>(
+ values: &mut [T],
+ key_getter: impl Fn(&mut T) -> &mut Val,
+) -> Result<SortKeyType> {
+ let mut sort_type = SortKeyType::Unknown;
+ for i in values.iter_mut() {
+ let i = key_getter(i);
+ match (i, sort_type) {
+ (Val::Str(_), SortKeyType::Unknown) => sort_type = SortKeyType::String,
+ (Val::Num(_), SortKeyType::Unknown) => sort_type = SortKeyType::Number,
+ (Val::Str(_), SortKeyType::String) | (Val::Num(_), SortKeyType::Number) => {}
+ (Val::Str(_) | Val::Num(_), _) => {
+ throw_runtime!("sort elements should have same types")
+ }
+ _ => throw_runtime!("sort key should be string or number"),
+ }
+ }
+ Ok(sort_type)
+}
+
+/// * `key_getter` - None, if identity sort required
+pub fn sort(s: State, values: Cc<Vec<Val>>, key_getter: FuncVal) -> Result<Cc<Vec<Val>>> {
+ if values.len() <= 1 {
+ return Ok(values);
+ }
+ if key_getter.is_identity() {
+ // Fast path, identity key getter
+ let mut values = (*values).clone();
+ let sort_type = get_sort_type(&mut values, |k| k)?;
+ match sort_type {
+ SortKeyType::Number => values.sort_unstable_by_key(|v| match v {
+ Val::Num(n) => NonNaNf64(*n),
+ _ => unreachable!(),
+ }),
+ SortKeyType::String => values.sort_unstable_by_key(|v| match v {
+ Val::Str(s) => s.clone(),
+ _ => unreachable!(),
+ }),
+ SortKeyType::Unknown => unreachable!(),
+ };
+ Ok(Cc::new(values))
+ } else {
+ // Slow path, user provided key getter
+ let mut vk = Vec::with_capacity(values.len());
+ for value in values.iter() {
+ vk.push((
+ value.clone(),
+ key_getter.evaluate_simple(s.clone(), &(Any(value.clone()),))?,
+ ));
+ }
+ let sort_type = get_sort_type(&mut vk, |v| &mut v.1)?;
+ match sort_type {
+ SortKeyType::Number => vk.sort_by_key(|v| match v.1 {
+ Val::Num(n) => NonNaNf64(n),
+ _ => unreachable!(),
+ }),
+ SortKeyType::String => vk.sort_by_key(|v| match &v.1 {
+ Val::Str(s) => s.clone(),
+ _ => unreachable!(),
+ }),
+ SortKeyType::Unknown => unreachable!(),
+ };
+ Ok(Cc::new(vk.into_iter().map(|v| v.0).collect()))
+ }
+}
+
+#[builtin]
+#[allow(non_snake_case)]
+pub fn builtin_sort(s: State, arr: ArrValue, keyF: Option<FuncVal>) -> Result<ArrValue> {
+ if arr.len() <= 1 {
+ return Ok(arr);
+ }
+ Ok(ArrValue::Eager(super::sort::sort(
+ s.clone(),
+ arr.evaluated(s)?,
+ keyF.unwrap_or_else(FuncVal::identity),
+ )?))
+}
crates/jrsonnet-stdlib/src/std.jsonnetdiffbeforeafterboth--- a/crates/jrsonnet-stdlib/src/std.jsonnet
+++ b/crates/jrsonnet-stdlib/src/std.jsonnet
@@ -2,62 +2,11 @@
local std = self,
local id = std.id,
- # Magic legacy field
- thisFile:: $intrinsicThisFile,
- id:: $intrinsicId,
-
- # Those functions aren't normally located in stdlib
- length:: $intrinsic(length),
- type:: $intrinsic(type),
- makeArray:: $intrinsic(makeArray),
- codepoint:: $intrinsic(codepoint),
- objectFieldsEx:: $intrinsic(objectFieldsEx),
- objectHasEx:: $intrinsic(objectHasEx),
- primitiveEquals:: $intrinsic(primitiveEquals),
- modulo:: $intrinsic(modulo),
- floor:: $intrinsic(floor),
- ceil:: $intrinsic(ceil),
- extVar:: $intrinsic(extVar),
- native:: $intrinsic(native),
- filter:: $intrinsic(filter),
- char:: $intrinsic(char),
- encodeUTF8:: $intrinsic(encodeUTF8),
- decodeUTF8:: $intrinsic(decodeUTF8),
- md5:: $intrinsic(md5),
- trace:: $intrinsic(trace),
- parseJson:: $intrinsic(parseJson),
- parseYaml:: $intrinsic(parseYaml),
-
- log:: $intrinsic(log),
- pow:: $intrinsic(pow),
- sqrt:: $intrinsic(sqrt),
-
- sin:: $intrinsic(sin),
- cos:: $intrinsic(cos),
- tan:: $intrinsic(tan),
- asin:: $intrinsic(asin),
- acos:: $intrinsic(acos),
- atan:: $intrinsic(atan),
-
- exp:: $intrinsic(exp),
- mantissa:: $intrinsic(mantissa),
- exponent:: $intrinsic(exponent),
+ thisFile:: error 'std.thisFile is deprecated, to enable its support in jrsonnet - recompile it with "legacy-this-file" support. This will slow down stdlib caching a bit, though',
- any:: $intrinsic(any),
- all:: $intrinsic(all),
-
- isString(v):: std.type(v) == 'string',
- isNumber(v):: std.type(v) == 'number',
- isBoolean(v):: std.type(v) == 'boolean',
- isObject(v):: std.type(v) == 'object',
- isArray(v):: std.type(v) == 'array',
- isFunction(v):: std.type(v) == 'function',
-
toString(a)::
if std.type(a) == 'string' then a else '' + a,
- substr:: $intrinsic(substr),
-
startsWith(a, b)::
if std.length(a) < std.length(b) then
false
@@ -127,33 +76,13 @@
split(str, c):: std.splitLimit(str, c, -1),
- splitLimit:: $intrinsic(splitLimit),
-
- strReplace:: $intrinsic(strReplace),
-
- asciiUpper:: $intrinsic(asciiUpper),
-
- asciiLower:: $intrinsic(asciiLower),
-
- range:: $intrinsic(range),
-
repeat(what, count)::
local joiner =
if std.isString(what) then ''
else if std.isArray(what) then []
else error 'std.repeat first argument must be an array or a string';
std.join(joiner, std.makeArray(count, function(i) what)),
-
- slice:: $intrinsic(slice),
- member:: $intrinsic(member),
-
- count:: $intrinsic(count),
-
- mod:: $intrinsic(mod),
-
- map:: $intrinsic(map),
-
mapWithIndex(func, arr)::
if !std.isFunction(func) then
error ('std.mapWithIndex first param must be function, got ' + std.type(func))
@@ -169,11 +98,7 @@
error ('std.mapWithKey second param must be object, got ' + std.type(obj))
else
{ [k]: func(k, obj[k]) for k in std.objectFields(obj) },
-
- flatMap:: $intrinsic(flatMap),
- join:: $intrinsic(join),
-
lines(arr)::
std.join('\n', arr + ['']),
@@ -184,14 +109,7 @@
std.join('', [std.deepJoin(x) for x in arr])
else
error 'Expected string or array, got %s' % std.type(arr),
-
- format:: $intrinsic(format),
-
- foldr:: $intrinsic(foldr),
-
- foldl:: $intrinsic(foldl),
-
filterMap(filter_func, map_func, arr)::
if !std.isFunction(filter_func) then
error ('std.filterMap first param must be function, got ' + std.type(filter_func))
@@ -350,8 +268,6 @@
else
error 'TOML body must be an object. Got ' + std.type(value),
- escapeStringJson:: $intrinsic(escapeStringJson),
-
escapeStringPython(str)::
std.escapeStringJson(str),
@@ -376,11 +292,7 @@
manifestJson(value):: std.manifestJsonEx(value, ' ') tailstrict,
manifestJsonMinified(value):: std.manifestJsonEx(value, '', '', ':'),
-
- manifestJsonEx:: $intrinsic(manifestJsonEx),
- manifestYamlDoc:: $intrinsic(manifestYamlDoc),
-
manifestYamlStream(value, indent_array_in_object=false, c_document_end=true)::
if !std.isArray(value) then
error 'manifestYamlStream only takes arrays, got ' + std.type(value)
@@ -433,20 +345,7 @@
std.deepJoin(['<', tag, attrs_str, '>', [aux(x) for x in children], '</', tag, '>']);
aux(value),
-
- local base64_table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
- local base64_inv = { [base64_table[i]]: i for i in std.range(0, 63) },
-
- base64:: $intrinsic(base64),
-
- base64DecodeBytes:: $intrinsic(base64DecodeBytes),
-
- base64Decode:: $intrinsic(base64Decode),
-
- reverse:: $intrinsic(reverse),
- sort:: $intrinsic(sort),
-
uniq(arr, keyF=id)::
local f(a, b) =
if std.length(a) == 0 then
@@ -534,7 +433,7 @@
else
patch,
- get(o, f, default = null, inc_hidden = true)::
+ get(o, f, default=null, inc_hidden=true)::
if std.objectHasEx(o, f, inc_hidden) then o[f] else default,
objectFields(o)::
@@ -554,8 +453,6 @@
objectValuesAll(o)::
[o[k] for k in std.objectFieldsAll(o)],
-
- equals:: $intrinsic(equals),
resolvePath(f, r)::
local arr = std.split(f, '/');
crates/jrsonnet-stdlib/src/types.rsdiffbeforeafterboth--- /dev/null
+++ b/crates/jrsonnet-stdlib/src/types.rs
@@ -0,0 +1,31 @@
+use jrsonnet_evaluator::{error::Result, function::builtin, typed::Any, IStr, Val};
+
+#[builtin]
+pub fn builtin_type(x: Any) -> Result<IStr> {
+ Ok(x.0.value_type().name().into())
+}
+
+#[builtin]
+pub fn builtin_is_string(x: Any) -> Result<bool> {
+ Ok(matches!(x.0, Val::Str(_)))
+}
+#[builtin]
+pub fn builtin_is_number(x: Any) -> Result<bool> {
+ Ok(matches!(x.0, Val::Num(_)))
+}
+#[builtin]
+pub fn builtin_is_boolean(x: Any) -> Result<bool> {
+ Ok(matches!(x.0, Val::Bool(_)))
+}
+#[builtin]
+pub fn builtin_is_object(x: Any) -> Result<bool> {
+ Ok(matches!(x.0, Val::Obj(_)))
+}
+#[builtin]
+pub fn builtin_is_array(x: Any) -> Result<bool> {
+ Ok(matches!(x.0, Val::Arr(_)))
+}
+#[builtin]
+pub fn builtin_is_function(x: Any) -> Result<bool> {
+ Ok(matches!(x.0, Val::Func(_)))
+}