fix(engine-ecs): make pair macro work for creating pairs with data

1 files changed, 90 insertions, 5 deletions

diff --git a/engine-ecs/src/pair.rs b/engine-ecs/src/pair.rs
index 3d603a8..98f0257 100644
--- a/engine-ecs/src/pair.rs
+++ b/engine-ecs/src/pair.rs
@@ -1,9 +1,13 @@
-use std::any::{TypeId, type_name};
+use std::any::{type_name, TypeId};
 use std::convert::Infallible;
 use std::marker::PhantomData;
 
 use crate::component::{
-    Handle as ComponentHandle, HandleError as ComponentHandleError, HandleMut as ComponentHandleMut, IntoParts as IntoComponentParts, Parts as ComponentParts,
+    Handle as ComponentHandle,
+    HandleError as ComponentHandleError,
+    HandleMut as ComponentHandleMut,
+    IntoParts as IntoComponentParts,
+    Parts as ComponentParts,
 };
 use crate::entity::{
     Handle as EntityHandle,
@@ -768,7 +772,6 @@ pub struct MemberMetadata
     pub name: &'static str,
 }
 
-
 #[macro_export]
 macro_rules! pair {
 
@@ -802,7 +805,29 @@ macro_rules! pair {
         }
     };
 
+    (={ $relation: expr }, $target: tt) => {
+        $crate::pair!(@inner (=, { $relation }), (, $target))
+    };
+
+    ($relation: tt, ={ $target: expr }) => {
+        $crate::pair!(@inner (,$relation), (=, { $target }))
+    };
+
     ($relation: tt, $target: tt) => {
+        $crate::pair!(@inner (,$relation), (, $target))
+    };
+
+    (
+        @inner
+        (
+            $(=$($relation_eq: literal)?)?,
+            $relation: tt
+        ),
+        (
+            $(=$($target_eq: literal)?)?,
+            $target: tt
+        )
+    ) => {
         {
             #[allow(dead_code)]
             fn get_type_uid<T: $crate::pair::ComponentOrWildcard>()
@@ -813,8 +838,13 @@ macro_rules! pair {
 
             let builder = $crate::pair::Pair::builder();
 
-            $crate::pair!(@set_member_in_builder, builder, relation, $relation);
-            $crate::pair!(@set_member_in_builder, builder, target, $target);
+            $crate::pair!(
+                @set_member_in_builder, builder, relation, $(=$($relation_eq)?)? $relation
+            );
+
+            $crate::pair!(
+                @set_member_in_builder, builder, target, $(=$($target_eq)?)? $target
+            );
 
             builder.build()
         }
@@ -854,3 +884,58 @@ mod sealed
     pub trait Sealed {}
 }
 
+#[cfg(test)]
+mod tests
+{
+    use crate::pair::ChildOf;
+    use crate::uid::Uid;
+    use crate::Component;
+
+    #[derive(Debug, Component)]
+    struct Foo;
+
+    #[derive(Debug, Component, PartialEq, Eq)]
+    struct Bar
+    {
+        number: u32,
+    }
+
+    #[test]
+    fn macro_works()
+    {
+        let pair_a = pair!(ChildOf, Foo);
+
+        assert_eq!(pair_a.relation, ChildOf::id());
+        assert_eq!(pair_a.target, Foo::id());
+
+        let pair_b = pair!(ChildOf, *);
+
+        assert_eq!(pair_b.relation, ChildOf::id());
+        assert_eq!(pair_b.target, Uid::wildcard());
+
+        let pair_c = pair!(*, Foo);
+
+        assert_eq!(pair_c.relation, Uid::wildcard());
+        assert_eq!(pair_c.target, Foo::id());
+
+        let pair_d = pair!(Foo, ={ Bar { number: 1234 } });
+
+        assert_eq!(pair_d.relation, Foo::id());
+        assert_eq!(pair_d.target, Bar { number: 1234 });
+
+        let pair_e = pair!(={ Bar { number: 789} }, Foo);
+
+        assert_eq!(pair_e.relation, Bar { number: 789 });
+        assert_eq!(pair_e.target, Foo::id());
+
+        let pair_f = pair!(ChildOf, { Foo::id() });
+
+        assert_eq!(pair_f.relation, ChildOf::id());
+        assert_eq!(pair_f.target, Foo::id());
+
+        let pair_g = pair!({ Bar::id() }, Foo);
+
+        assert_eq!(pair_g.relation, Bar::id());
+        assert_eq!(pair_g.target, Foo::id());
+    }
+}