git.delta.rocks / jrsonnet / refs/commits / fab41c8db644

--- a/crates/jsonnet-evaluator/Cargo.toml
+++ b/crates/jsonnet-evaluator/Cargo.toml
@@ -9,6 +9,4 @@
 [dependencies]
 jsonnet-parser = { path = "../jsonnet-parser" }
 closure = "0.3.0"
-
-[dev-dependencies]
 jsonnet-stdlib = { version = "0.1.0", path = "../jsonnet-stdlib" }

--- a/crates/jsonnet-evaluator/src/ctx.rs
+++ b/crates/jsonnet-evaluator/src/ctx.rs
@@ -1,5 +1,6 @@
 use crate::{
-	future_wrapper, lazy_binding, lazy_val, rc_fn_helper, LazyBinding, LazyVal, ObjValue, Val,
+	future_wrapper, lazy_binding, lazy_val, rc_fn_helper, LazyBinding, LazyVal, ObjValue, Result,
+	Val,
 };
 use closure::closure;
 use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};
@@ -7,7 +8,7 @@
 rc_fn_helper!(
 	ContextCreator,
 	context_creator,
-	dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Context
+	dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Result<Context>
 );
 
 future_wrapper!(Context, FutureContext);
@@ -65,12 +66,12 @@
 		ctx.unwrap()
 	}
 
-	pub fn with_var(&self, name: String, value: Val) -> Context {
+	pub fn with_var(&self, name: String, value: Val) -> Result<Context> {
 		let mut new_bindings: HashMap<_, LazyBinding> = HashMap::new();
 		new_bindings.insert(
 			name,
 			lazy_binding!(
-				closure!(clone value, |_t, _s|lazy_val!(closure!(clone value, ||value.clone())))
+				closure!(clone value, |_t, _s|Ok(lazy_val!(closure!(clone value, ||Ok(value.clone())))))
 			),
 		);
 		self.extend(new_bindings, None, None, None)
@@ -82,7 +83,7 @@
 		new_dollar: Option<ObjValue>,
 		new_this: Option<ObjValue>,
 		new_super_obj: Option<ObjValue>,
-	) -> Context {
+	) -> Result<Context> {
 		let dollar = new_dollar.or_else(|| self.0.dollar.clone());
 		let this = new_this.or_else(|| self.0.this.clone());
 		let super_obj = new_super_obj.or_else(|| self.0.super_obj.clone());
@@ -94,16 +95,16 @@
 				new.insert(k.clone(), v.clone());
 			}
 			for (k, v) in new_bindings.into_iter() {
-				new.insert(k, v.0(this.clone(), super_obj.clone()));
+				new.insert(k, v.0(this.clone(), super_obj.clone())?);
 			}
 			Rc::new(new)
 		};
-		Context(Rc::new(ContextInternals {
+		Ok(Context(Rc::new(ContextInternals {
 			dollar,
 			this,
 			super_obj,
 			bindings,
-		}))
+		})))
 	}
 }
 

--- a/crates/jsonnet-evaluator/src/error.rs
+++ b/crates/jsonnet-evaluator/src/error.rs
@@ -1 +1,20 @@
-pub enum Error {}
+use crate::ValType;
+use jsonnet_parser::LocExpr;
+
+#[derive(Debug)]
+pub enum Error {
+	VariableIsNotDefined(String),
+	TypeMismatch(&'static str, Vec<ValType>, ValType),
+	NoSuchField(String),
+
+	RuntimeError(String),
+}
+
+#[derive(Clone, Debug)]
+pub struct StackTraceElement(pub LocExpr, pub String);
+#[derive(Debug)]
+pub struct StackTrace(pub Vec<StackTraceElement>);
+
+#[derive(Debug)]
+pub struct LocError(pub Error, pub StackTrace);
+pub type Result<V> = std::result::Result<V, LocError>;

--- a/crates/jsonnet-evaluator/src/lib.rs
+++ b/crates/jsonnet-evaluator/src/lib.rs
@@ -22,41 +22,59 @@
 rc_fn_helper!(
 	Binding,
 	binding,
-	dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Val
+	dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Result<Val>
 );
 rc_fn_helper!(
 	LazyBinding,
 	lazy_binding,
-	dyn Fn(Option<ObjValue>, Option<ObjValue>) -> LazyVal
+	dyn Fn(Option<ObjValue>, Option<ObjValue>) -> Result<LazyVal>
 );
-rc_fn_helper!(FunctionRhs, function_rhs, dyn Fn(Context) -> Val);
+rc_fn_helper!(FunctionRhs, function_rhs, dyn Fn(Context) -> Result<Val>);
 rc_fn_helper!(
 	FunctionDefault,
 	function_default,
-	dyn Fn(Context, LocExpr) -> Val
+	dyn Fn(Context, LocExpr) -> Result<Val>
 );
 
+pub struct FileData(String, LocExpr, Option<Val>);
 #[derive(Default)]
 pub struct EvaluationStateInternals {
 	/// Used for stack-overflows and stacktraces
-	stack: RefCell<Vec<(LocExpr, String)>>,
+	stack: RefCell<Vec<StackTraceElement>>,
 	/// Contains file source codes and evaluated results for imports and pretty printing stacktraces
-	files: RefCell<HashMap<String, (String, LocExpr, Option<Val>)>>,
+	files: RefCell<HashMap<String, FileData>>,
 	globals: RefCell<HashMap<String, Val>>,
 }
 
+thread_local! {
+	pub static EVAL_STATE: RefCell<Option<EvaluationState>> = RefCell::new(None)
+}
+pub(crate) fn with_state<T>(f: impl FnOnce(&EvaluationState) -> T) -> T {
+	EVAL_STATE.with(|s| f(s.borrow().as_ref().unwrap()))
+}
+pub(crate) fn create_error<T>(err: Error) -> Result<T> {
+	with_state(|s| s.error(err))
+}
+pub(crate) fn push<T>(e: LocExpr, comment: String, f: impl FnOnce() -> T) -> T {
+	with_state(|s| s.push(e, comment, f))
+}
+
 #[derive(Default, Clone)]
 pub struct EvaluationState(Rc<EvaluationStateInternals>);
 impl EvaluationState {
-	pub fn add_file(&self, name: String, code: String) -> Result<(), Box<dyn std::error::Error>> {
+	pub fn add_file(
+		&self,
+		name: String,
+		code: String,
+	) -> std::result::Result<(), Box<dyn std::error::Error>> {
 		self.0.files.borrow_mut().insert(
 			name.clone(),
-			(
+			FileData(
 				code.clone(),
 				parse(
 					&code,
 					&ParserSettings {
-						file_name: name.clone(),
+						file_name: name,
 						loc_data: true,
 					},
 				)?,
@@ -66,7 +84,8 @@
 
 		Ok(())
 	}
-	pub fn evaluate_file(&self, name: &str) -> Result<Val, Box<dyn std::error::Error>> {
+	pub fn evaluate_file(&self, name: &str) -> Result<Val> {
+		self.begin_state();
 		let expr: LocExpr = {
 			let ro_map = self.0.files.borrow();
 			let value = ro_map
@@ -77,7 +96,7 @@
 			}
 			value.1.clone()
 		};
-		let value = evaluate(self.create_default_context(), self.clone(), &expr);
+		let value = evaluate(self.create_default_context()?, &expr)?;
 		{
 			self.0
 				.files
@@ -87,10 +106,11 @@
 				.2
 				.replace(value.clone());
 		}
+		self.end_state();
 		Ok(value)
 	}
 
-	pub fn parse_evaluate_raw(&self, code: &str) -> Val {
+	pub fn parse_evaluate_raw(&self, code: &str) -> Result<Val> {
 		let parsed = parse(
 			&code,
 			&ParserSettings {
@@ -98,29 +118,30 @@
 				loc_data: true,
 			},
 		);
-		evaluate(
-			self.create_default_context(),
-			self.clone(),
-			&parsed.unwrap(),
-		)
+		self.begin_state();
+		let value = evaluate(self.create_default_context()?, &parsed.unwrap());
+		self.end_state();
+		value
 	}
 
 	pub fn add_stdlib(&self) {
+		self.begin_state();
 		use jsonnet_stdlib::STDLIB_STR;
 		self.add_file("std.jsonnet".to_owned(), STDLIB_STR.to_owned())
 			.unwrap();
 		let val = self.evaluate_file("std.jsonnet").unwrap();
 		self.0.globals.borrow_mut().insert("std".to_owned(), val);
+		self.end_state();
 	}
 
-	pub fn create_default_context(&self) -> Context {
+	pub fn create_default_context(&self) -> Result<Context> {
 		let globals = self.0.globals.borrow();
 		let mut new_bindings: HashMap<String, LazyBinding> = HashMap::new();
 		for (name, value) in globals.iter() {
 			new_bindings.insert(
 				name.clone(),
 				lazy_binding!(
-					closure!(clone value, |_self, _super_obj| lazy_val!(closure!(clone value, ||value.clone())))
+					closure!(clone value, |_self, _super_obj| Ok(lazy_val!(closure!(clone value, ||Ok(value.clone())))))
 				),
 			);
 		}
@@ -128,30 +149,37 @@
 	}
 
 	pub fn push<T>(&self, e: LocExpr, comment: String, f: impl FnOnce() -> T) -> T {
-		self.0.stack.borrow_mut().push((e, comment));
+		self.0
+			.stack
+			.borrow_mut()
+			.push(StackTraceElement(e, comment));
 		let result = f();
 		self.0.stack.borrow_mut().pop();
 		result
 	}
 	pub fn print_stack_trace(&self) {
-		for e in self.stack_trace() {
+		for e in self.stack_trace().0 {
 			println!("{:?} - {:?}", e.0, e.1)
 		}
 	}
-	pub fn stack_trace(&self) -> Vec<(LocExpr, String)> {
-		self.0
-			.stack
-			.borrow()
-			.iter()
-			.rev()
-			.map(|e| e.clone())
-			.collect()
+	pub fn stack_trace(&self) -> StackTrace {
+		StackTrace(self.0.stack.borrow().iter().rev().cloned().collect())
+	}
+	pub fn error<T>(&self, err: Error) -> Result<T> {
+		Err(LocError(err, self.stack_trace()))
+	}
+
+	fn begin_state(&self) {
+		EVAL_STATE.with(|v| v.borrow_mut().replace(self.clone()));
+	}
+	fn end_state(&self) {
+		EVAL_STATE.with(|v| v.borrow_mut().take());
 	}
 }
 
 #[cfg(test)]
 pub mod tests {
-	use super::{evaluate, Context, Val};
+	use super::Val;
 	use crate::EvaluationState;
 	use jsonnet_parser::*;
 
@@ -176,7 +204,9 @@
 		let state = EvaluationState::default();
 		state.add_stdlib();
 		assert_eq!(
-			state.parse_evaluate_raw(r#"std.base64("test") == "dGVzdA==""#),
+			state
+				.parse_evaluate_raw(r#"std.assertEqual(std.base64("test"), "dGVzdA==w")"#)
+				.unwrap(),
 			Val::Bool(true)
 		);
 	}
@@ -282,6 +312,7 @@
 		};
 	}
 
+	/*
 	/// Sanity checking, before trusting to another tests
 	#[test]
 	fn equality_operator() {
@@ -491,4 +522,5 @@
 		"#
 		);
 	}
+	*/
 }

--- a/crates/jsonnet-evaluator/src/obj.rs
+++ b/crates/jsonnet-evaluator/src/obj.rs
@@ -1,4 +1,4 @@
-use crate::{evaluate_add_op, Binding, Val};
+use crate::{evaluate_add_op, Binding, Result, Val};
 use jsonnet_parser::Visibility;
 use std::{
 	cell::RefCell,
@@ -32,13 +32,10 @@
 			write!(f, " + ")?;
 		}
 		let mut debug = f.debug_struct("ObjValue");
-		debug.field("$ptr", &Rc::as_ptr(&self.0));
 		for (name, member) in self.0.this_entries.iter() {
 			debug.field(name, member);
 		}
 		debug.finish_non_exhaustive()
-		// .field("fields", &self.fields())
-		// .finish_non_exhaustive()
 	}
 }
 
@@ -71,33 +68,40 @@
 		}
 		fields
 	}
-	pub fn get(&self, key: &str) -> Option<Val> {
+	pub fn get(&self, key: &str) -> Result<Option<Val>> {
 		if let Some(v) = self.0.value_cache.borrow().get(key) {
-			return Some(v.clone());
+			return Ok(Some(v.clone()));
 		}
-		let v = self.get_raw(key, self).map(|v| v.unwrap_if_lazy());
-		if let Some(v) = v.clone() {
-			self.0.value_cache.borrow_mut().insert(key.to_owned(), v);
+		if let Some(v) = self.get_raw(key, self)? {
+			let v = v.unwrap_if_lazy()?;
+			self.0
+				.value_cache
+				.borrow_mut()
+				.insert(key.to_owned(), v.clone());
+			Ok(Some(v))
+		} else {
+			Ok(None)
 		}
-		v
 	}
-	fn get_raw(&self, key: &str, real_this: &ObjValue) -> Option<Val> {
+	fn get_raw(&self, key: &str, real_this: &ObjValue) -> Result<Option<Val>> {
 		match (self.0.this_entries.get(key), &self.0.super_obj) {
-			(Some(k), None) => Some(k.invoke.0(
+			(Some(k), None) => Ok(Some(k.invoke.0(
 				Some(real_this.clone()),
 				self.0.super_obj.clone(),
-			)),
+			)?)),
 			(Some(k), Some(s)) => {
-				let our = k.invoke.0(Some(real_this.clone()), self.0.super_obj.clone());
+				let our = k.invoke.0(Some(real_this.clone()), self.0.super_obj.clone())?;
 				if k.add {
-					s.get_raw(key, real_this)
-						.map_or(Some(our.clone()), |v| Some(evaluate_add_op(&v, &our)))
+					s.get_raw(key, real_this)?
+						.map_or(Ok(Some(our.clone())), |v| {
+							Ok(Some(evaluate_add_op(&v, &our)?))
+						})
 				} else {
-					Some(our)
+					Ok(Some(our))
 				}
 			}
 			(None, Some(s)) => s.get_raw(key, real_this),
-			(None, None) => None,
+			(None, None) => Ok(None),
 		}
 	}
 }

--- a/crates/jsonnet-evaluator/src/val.rs
+++ b/crates/jsonnet-evaluator/src/val.rs
@@ -1,4 +1,7 @@
-use crate::{lazy_binding, Context, FunctionDefault, FunctionRhs, LazyBinding, ObjValue};
+use crate::{
+	create_error, lazy_binding, Context, Error, FunctionDefault, FunctionRhs, LazyBinding,
+	ObjValue, Result,
+};
 use closure::closure;
 use jsonnet_parser::ParamsDesc;
 use std::{
@@ -9,28 +12,28 @@
 };
 
 struct LazyValInternals {
-	pub f: Box<dyn Fn() -> Val>,
+	pub f: Box<dyn Fn() -> Result<Val>>,
 	pub cached: RefCell<Option<Val>>,
 }
 #[derive(Clone)]
 pub struct LazyVal(Rc<LazyValInternals>);
 impl LazyVal {
-	pub fn new(f: Box<dyn Fn() -> Val>) -> Self {
+	pub fn new(f: Box<dyn Fn() -> Result<Val>>) -> Self {
 		LazyVal(Rc::new(LazyValInternals {
 			f,
 			cached: RefCell::new(None),
 		}))
 	}
-	pub fn evaluate(&self) -> Val {
+	pub fn evaluate(&self) -> Result<Val> {
 		{
 			let cached = self.0.cached.borrow();
 			if cached.is_some() {
-				return cached.clone().unwrap();
+				return Ok(cached.clone().unwrap());
 			}
 		}
-		let result = (self.0.f)();
+		let result = (self.0.f)()?;
 		self.0.cached.borrow_mut().replace(result.clone());
-		result
+		Ok(result)
 	}
 }
 #[macro_export]
@@ -59,7 +62,7 @@
 }
 impl FuncDesc {
 	// TODO: Check for unset variables
-	pub fn evaluate(&self, args: Vec<(Option<String>, Val)>) -> Val {
+	pub fn evaluate(&self, args: Vec<(Option<String>, Val)>) -> Result<Val> {
 		let mut new_bindings: HashMap<String, LazyBinding> = HashMap::new();
 		let future_ctx = Context::new_future();
 
@@ -80,7 +83,7 @@
 			new_bindings.insert(
 				name.as_ref().unwrap().clone(),
 				lazy_binding!(
-					closure!(clone val, |_, _| lazy_val!(closure!(clone val, || val.clone())))
+					closure!(clone val, |_, _| Ok(lazy_val!(closure!(clone val, || Ok(val.clone())))))
 				),
 			);
 		}
@@ -89,19 +92,49 @@
 				new_bindings.insert(
 					param.0.clone(),
 					lazy_binding!(
-						closure!(clone val, |_, _| lazy_val!(closure!(clone val, || val.clone())))
+						closure!(clone val, |_, _| Ok(lazy_val!(closure!(clone val, || Ok(val.clone())))))
 					),
 				);
 			}
 		}
 		let ctx = self
 			.ctx
-			.extend(new_bindings, None, None, None)
+			.extend(new_bindings, None, None, None)?
 			.into_future(future_ctx);
 		self.eval_rhs.0(ctx)
 	}
 }
 
+#[derive(Debug)]
+pub enum ValType {
+	Bool,
+	Null,
+	Str,
+	Num,
+	Arr,
+	Obj,
+	Func,
+}
+impl ValType {
+	pub fn name(&self) -> &'static str {
+		use ValType::*;
+		match self {
+			Bool => "boolean",
+			Null => "null",
+			Str => "string",
+			Num => "number",
+			Arr => "array",
+			Obj => "object",
+			Func => "function",
+		}
+	}
+}
+impl Display for ValType {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{}", self.name())
+	}
+}
+
 #[derive(Debug, PartialEq, Clone)]
 pub enum Val {
 	Bool(bool),
@@ -117,80 +150,44 @@
 	Intristic(String, String),
 }
 impl Val {
-	pub fn try_cast_bool(self) -> bool {
-		match self.unwrap_if_lazy() {
-			Val::Bool(v) => v,
-			v => panic!("expected bool, got {:?}", v),
+	pub fn try_cast_bool(self, context: &'static str) -> Result<bool> {
+		match self.unwrap_if_lazy()? {
+			Val::Bool(v) => Ok(v),
+			v => create_error(Error::TypeMismatch(
+				context,
+				vec![ValType::Bool],
+				v.value_type()?,
+			)),
 		}
 	}
-	pub fn try_cast_str(self) -> String {
-		match self.unwrap_if_lazy() {
-			Val::Str(v) => v,
-			v => panic!("expected bool, got {:?}", v),
+	pub fn try_cast_str(self, context: &'static str) -> Result<String> {
+		match self.unwrap_if_lazy()? {
+			Val::Str(v) => Ok(v),
+			v => create_error(Error::TypeMismatch(
+				context,
+				vec![ValType::Str],
+				v.value_type()?,
+			)),
 		}
 	}
-	pub fn unwrap_if_lazy(self) -> Self {
-		if let Val::Lazy(v) = self {
-			v.evaluate().unwrap_if_lazy()
+	pub fn unwrap_if_lazy(self) -> Result<Self> {
+		Ok(if let Val::Lazy(v) = self {
+			v.evaluate()?.unwrap_if_lazy()?
 		} else {
 			self
-		}
-	}
-	pub fn type_of(&self) -> &'static str {
-		match self {
-			Val::Str(..) => "string",
-			Val::Num(..) => "number",
-			Val::Arr(..) => "array",
-			Val::Obj(..) => "object",
-			Val::Func(..) => "function",
-			_ => panic!("no native type found"),
-		}
+		})
 	}
-}
-impl Display for Val {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		match self {
-			Val::Str(str) => write!(f, "\"{}\"", str)?,
-			Val::Num(n) => write!(f, "{}", n)?,
-			Val::Arr(values) => {
-				write!(f, "[")?;
-				let mut first = true;
-				for value in values {
-					if first {
-						first = false;
-					} else {
-						write!(f, ",")?;
-					}
-					write!(f, "{}", value)?;
-				}
-				write!(f, "]")?;
-			}
-			Val::Obj(value) => {
-				write!(f, "{{")?;
-				let mut first = true;
-				for field in value.fields() {
-					if first {
-						first = false;
-					} else {
-						write!(f, ",")?;
-					}
-					write!(f, "\"{}\":", field)?;
-					write!(f, "{}", value.get(&field).unwrap())?;
-				}
-				write!(f, "}}")?;
-			}
-			Val::Lazy(lazy) => {
-				write!(f, "{}", lazy.evaluate())?;
-			}
-			Val::Func(_) => {
-				write!(f, "<<FUNC>>")?;
-			}
-			v => panic!("no json equivalent for {:?}", v),
-		};
-		Ok(())
+	pub fn value_type(&self) -> Result<ValType> {
+		Ok(match self {
+			Val::Str(..) => ValType::Str,
+			Val::Num(..) => ValType::Num,
+			Val::Arr(..) => ValType::Arr,
+			Val::Obj(..) => ValType::Obj,
+			Val::Func(..) => ValType::Func,
+			Val::Bool(_) => ValType::Bool,
+			Val::Null => ValType::Null,
+			Val::Intristic(_, _) => ValType::Func,
+			Val::Lazy(_) => self.clone().unwrap_if_lazy()?.value_type()?,
+		})
 	}
-}
-
-pub fn bool_val(v: bool) -> Val {
-	Val::Bool(v)
 }