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

35								Member::Field(FieldMember {35								Member::Field(FieldMember {
36									name: FieldName::Fixed(name),36									name: FieldName::Fixed(name),
37									..37									..
38								}) if **name == *"join" || **name == *"manifestJsonEx" || **name == *"escapeStringJson"38								}) if **name == *"join" || **name == *"manifestJsonEx" || **name == *"escapeStringJson" || **name == *"equals"
39							)39							)
40						})40						})
41						.collect(),41						.collect(),

484				0, a, vec![];484				0, a, vec![];
485				1, b, vec![];485				1, b, vec![];
486			], {486			], {
487				Val::Bool(a == b)487				Val::Bool(primitive_equals(&a, &b)?)
488			}),488			}),
489			// faster
490			("std", "equals") => parse_args!(context, "std.equals", args, 2, [
491				0, a, vec![];
492				1, b, vec![];
493			], {
494				Val::Bool(equals(&a, &b)?)
495			}),
489			("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [496			("std", "modulo") => parse_args!(context, "std.modulo", args, 2, [
490				0, a: [Val::Num]!!Val::Num, vec![ValType::Num];497				0, a: [Val::Num]!!Val::Num, vec![ValType::Num];
491				1, b: [Val::Num]!!Val::Num, vec![ValType::Num];498				1, b: [Val::Num]!!Val::Num, vec![ValType::Num];

380#[cfg(test)]380#[cfg(test)]
381pub mod tests {381pub mod tests {
382	use super::Val;382	use super::Val;
383	use crate::EvaluationState;383	use crate::{create_error, EvaluationState, primitive_equals};
384	use jrsonnet_parser::*;384	use jrsonnet_parser::*;
385	use std::{path::PathBuf, rc::Rc};385	use std::{path::PathBuf, rc::Rc};
386386
411	fn eval_state_standard() {411	fn eval_state_standard() {
412		let state = EvaluationState::default();412		let state = EvaluationState::default();
413		state.with_stdlib();413		state.with_stdlib();
414		assert_eq!(414		assert!(
415			primitive_equals(
415			state416				&state.parse_evaluate_raw(r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#).unwrap(),
416				.parse_evaluate_raw(r#"std.assertEqual(std.base64("test"), "dGVzdA==")"#)
417				.unwrap(),
418			Val::Bool(true)417				&Val::Bool(true),
418			).unwrap()
419		);419		);
420	}420	}
421421
445	/// Asserts given code returns `true`445	/// Asserts given code returns `true`
446	macro_rules! assert_eval {446	macro_rules! assert_eval {
447		($str: expr) => {447		($str: expr) => {
448			assert_eq!(eval!($str), Val::Bool(true))448			assert!(primitive_equals(&eval!($str), &Val::Bool(true)).unwrap())
449		};449		};
450	}450	}
451451
452	/// Asserts given code returns `false`452	/// Asserts given code returns `false`
453	macro_rules! assert_eval_neg {453	macro_rules! assert_eval_neg {
454		($str: expr) => {454		($str: expr) => {
455			assert_eq!(eval!($str), Val::Bool(false))455			assert!(primitive_equals(&eval!($str), &Val::Bool(false)).unwrap())
456		};456		};
457	}457	}
458	macro_rules! assert_json {458	macro_rules! assert_json {
663663
664	#[test]664	#[test]
665	fn string_is_string() {665	fn string_is_string() {
666		assert_eq!(666		assert!(
667			primitive_equals(
667			eval!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),668				&eval!("local arr = 'hello'; (!std.isArray(arr)) && (!std.isString(arr))"),
668			Val::Bool(false)669				&Val::Bool(false),
670			).unwrap()
669		);671		);
670	}672	}
671673
768		})770		})
769	}771	}
772
773	#[test]
774	fn equality(){
775		println!("{:?}", jrsonnet_parser::parse("{ x: 1, y: 2 } == { x: 1, y: 2 }", &ParserSettings::default()));
776		assert_eval!("{ x: 1, y: 2 } == { x: 1, y: 2 }")
777	}
770}778}
771779

111	}111	}
112}112}
113113
114#[derive(Debug, PartialEq, Clone)]114#[derive(Debug, Clone)]
115pub enum Val {115pub enum Val {
116	Bool(bool),116	Bool(bool),
117	Null,117	Null,
212	}212	}
213}213}
214
215fn is_function_like(val: &Val) -> bool {
216	matches!(val, Val::Func(_) | Val::Intristic(_, _))
217}
218
219/// Implements std.primitiveEquals builtin
220pub fn primitive_equals(val_a: &Val, val_b: &Val) -> Result<bool> {
221	Ok(match (val_a.unwrap_if_lazy()?, val_b.unwrap_if_lazy()?) {
222		(Val::Bool(a), Val::Bool(b)) => a == b,
223		(Val::Null, Val::Null) => true,
224		(Val::Str(a), Val::Str(b)) => a == b,
225		(Val::Num(a), Val::Num(b)) => (a - b).abs() <= f64::EPSILON,
226		(Val::Arr(_), Val::Arr(_)) => create_error_result(Error::RuntimeError(
227			"primitiveEquals operates on primitive types, got array".into(),
228		))?,
229		(Val::Obj(_), Val::Obj(_)) => create_error_result(Error::RuntimeError(
230			"primitiveEquals operates on primitive types, got object".into(),
231		))?,
232		(a, b) if is_function_like(&a) && is_function_like(&b) => create_error_result(
233			Error::RuntimeError("cannot test equality of functions".into()),
234		)?,
235		(_, _) => false,
236	})
237}
238
239/// Native implementation of std.equals
240pub fn equals(val_a: &Val, val_b: &Val) -> Result<bool> {
241	let val_a = val_a.unwrap_if_lazy()?;
242	let val_b = val_b.unwrap_if_lazy()?;
243
244	if val_a.value_type()? != val_b.value_type()? {
245		return Ok(false);
246	}
247	match (val_a, val_b) {
248		// Cant test for ptr equality, because all fields needs to be evaluated
249		(Val::Arr(a), Val::Arr(b)) => {
250			if a.len() != b.len() {
251				return Ok(false);
252			}
253			for (a, b) in a.iter().zip(b.iter()) {
254				if !equals(&a.unwrap_if_lazy()?, &b.unwrap_if_lazy()?)? {
255					return Ok(false);
256				}
257			}
258			Ok(true)
259		}
260		(Val::Obj(a), Val::Obj(b)) => {
261			let fields = a.visible_fields();
262			if fields != b.visible_fields() {
263				return Ok(false);
264			}
265			for field in fields {
266				if !equals(&a.get(field.clone())?.unwrap(), &b.get(field)?.unwrap())? {
267					return Ok(false);
268				}
269			}
270			Ok(true)
271		}
272		(a, b) => Ok(primitive_equals(&a, &b)?),
273	}
274}
214275
215pub fn manifest_json_ex(val: &Val, padding: &str) -> Result<String> {276pub fn manifest_json_ex(val: &Val, padding: &str) -> Result<String> {
216	let mut out = String::new();277	let mut out = String::new();