git.delta.rocks / jrsonnet / refs/commits / 59f19ba582ad

--- a/crates/jrsonnet-stdlib/src/arrays.rs
+++ b/crates/jrsonnet-stdlib/src/arrays.rs
@@ -3,7 +3,6 @@
 use jrsonnet_evaluator::{
 	Either, IStr, ObjValue, ObjValueBuilder, Result, ResultExt, Thunk, Val, bail, error,
 	function::{NativeFn, builtin},
-	runtime_error,
 	typed::{BoundedUsize, Either2, FromUntyped},
 	val::{ArrValue, IndexableVal, equals},
 };
@@ -40,8 +39,7 @@
 	Ok(match what {
 		Either2::A(s) => Val::string(s.repeat(count as usize)),
 		Either2::B(arr) => Val::Arr(
-			ArrValue::repeated(arr, count)
-				.ok_or_else(|| runtime_error!("repeated length overflow"))?,
+			ArrValue::repeated(arr, count).ok_or_else(|| error!("repeated length overflow"))?,
 		),
 	})
 }

1use base64::{Engine, engine::general_purpose::STANDARD};1use base64::{Engine, engine::general_purpose::STANDARD};
2use jrsonnet_evaluator::{2use jrsonnet_evaluator::{
3	IBytes, IStr, Result, bail,3	IBytes, IStr, Result, bail, error,
4	function::builtin,4	function::builtin,
5	runtime_error,
6	typed::{Either, Either2},5	typed::{Either, Either2},
7};6};
87
35pub fn builtin_base64_decode_bytes(str: IStr) -> Result<IBytes> {34pub fn builtin_base64_decode_bytes(str: IStr) -> Result<IBytes> {
36	Ok(STANDARD35	Ok(STANDARD
37		.decode(str.as_bytes())36		.decode(str.as_bytes())
38		.map_err(|e| runtime_error!("invalid base64: {e}"))?37		.map_err(|e| error!("invalid base64: {e}"))?
39		.as_slice()38		.as_slice()
40		.into())39		.into())
41}40}
44pub fn builtin_base64_decode(str: IStr, #[default(false)] lossy: bool) -> Result<String> {43pub fn builtin_base64_decode(str: IStr, #[default(false)] lossy: bool) -> Result<String> {
45	let bytes = STANDARD44	let bytes = STANDARD
46		.decode(str.as_bytes())45		.decode(str.as_bytes())
47		.map_err(|e| runtime_error!("invalid base64: {e}"))?;46		.map_err(|e| error!("invalid base64: {e}"))?;
48	if lossy {47	if lossy {
49		Ok(String::from_utf8_lossy(&bytes).to_string())48		Ok(String::from_utf8_lossy(&bytes).to_string())
50	} else {49	} else {
51		String::from_utf8(bytes).map_err(|e| runtime_error!("bad utf8: {e}"))50		String::from_utf8(bytes).map_err(|e| error!("bad utf8: {e}"))
52	}51	}
53}52}
5453

--- a/crates/jrsonnet-stdlib/src/parse.rs
+++ b/crates/jrsonnet-stdlib/src/parse.rs
@@ -1,10 +1,9 @@
-use jrsonnet_evaluator::{IStr, Result, Val, function::builtin, runtime_error};
+use jrsonnet_evaluator::{IStr, Result, Val, error, function::builtin};
 use serde_saphyr::options;
 
 #[builtin]
 pub fn builtin_parse_json(str: IStr) -> Result<Val> {
-	let value: Val =
-		serde_json::from_str(&str).map_err(|e| runtime_error!("failed to parse json: {e}"))?;
+	let value: Val = serde_json::from_str(&str).map_err(|e| error!("failed to parse json: {e}"))?;
 	Ok(value)
 }
 
@@ -21,7 +20,7 @@
 			budget: None,
 		},
 	)
-	.map_err(|e| runtime_error!("failed to parse yaml: {e}"))?;
+	.map_err(|e| error!("failed to parse yaml: {e}"))?;
 
 	// saphyr and other yaml implementations disagree on how to handle an empty document in multi-document stream.
 	// Saphyr only considers document started after anything is emitted after the document delimiter

--- a/crates/jrsonnet-stdlib/src/strings.rs
+++ b/crates/jrsonnet-stdlib/src/strings.rs
@@ -206,17 +206,15 @@
 #[builtin]
 pub fn builtin_bigint(v: Either![f64, IStr]) -> Result<Val> {
 	use Either2::*;
-	use jrsonnet_evaluator::runtime_error;
+	use jrsonnet_evaluator::error;
 	Ok(match v {
-		A(a) => {
-			Val::BigInt(Box::new(a.to_string().parse().map_err(|e| {
-				runtime_error!("number is not convertible to bigint: {e}")
-			})?))
-		}
+		A(a) => Val::BigInt(Box::new(
+			a.to_string()
+				.parse()
+				.map_err(|e| error!("number is not convertible to bigint: {e}"))?,
+		)),
 		B(b) => Val::BigInt(Box::new(
-			b.as_str()
-				.parse()
-				.map_err(|e| runtime_error!("bad bigint: {e}"))?,
+			b.as_str().parse().map_err(|e| error!("bad bigint: {e}"))?,
 		)),
 	})
 }