Merge remote-tracking branch 'origin/main' into main

Author: erkerkiii

Gum.Composer/Unity/Runtime/MonoComposable.cs

@@ -0,0 +1,28 @@
+#if UNITY_2019_1_OR_NEWER
+using UnityEngine;
+
+namespace Gum.Composer.Unity.Runtime
+{
+    public abstract class MonoComposable : MonoBehaviour, IComposable
+    {
+        public Composition Composition { get; protected set; }
+        
+        protected virtual void Awake()
+        {
+            Composition = Composition.Create(GetAspects());
+        }
+
+        public Composition GetComposition()
+        {
+            return Composition;
+        }
+
+        protected virtual void OnDestroy()
+        {
+            Composition.Dispose();
+        }
+
+        protected abstract IAspect[] GetAspects();
+    }
+}
+#endif

README.md

@@ -44,7 +44,7 @@ Add this to the ```Packages\manifest.json```
 Dependencies
 ```
  "dependencies": {
-    "com.erkerkiii.gum":  "1.0.8"
+    "com.erkerkiii.gum":  "1.0.11"
     }
 ```
 
@@ -218,6 +218,24 @@ public void UseAspects(IComposable composable)
 }
 ```
 
+### MonoComposable 
+
+Composition are also available on Unity `MonoBehaviours `. Deriving from the abstract `MonoComposable` class enables using composition on Unity objects. `MonoComposable` class handles creation of composable, deriving classes only responsible for implementing the `GetAspects()` absrtact method to assign aspects.
+
+```CSharp
+public class FooMonoComposable : MonoComposable
+{
+    private int _value = 12;
+
+    protected override IAspect[] GetAspects() // Deriving class implements GetAspects method.
+    {
+        IAspect[] aspects = ArrayPool<IAspect>.GetPool(1).Get();
+        aspects[0] = new FooAspect(_value);
+        return aspects;
+    }
+}
+```
+
 ### Other usages
 ```CSharp
 composition
@@ -285,4 +303,4 @@ private void Bar(FooSignal fooSignal)
 signalCenter.Subscribe<FooSignal>(Action); //to subscribe
 signalCenter.Unsubscribe<FooSignal>(Action); //to unsubscribe
 signalCenter.Fire(new FooSignal()); //to fire signals
-```
+```

Tests/CompositionTests/Unity/FooMonoComposable.cs

@@ -0,0 +1,20 @@
+#if UNITY_2019_1_OR_NEWER
+using Gum.Composer;
+using Gum.Composer.Unity.Runtime;
+using Gum.Pooling;
+
+namespace Tests.CompositionTests.Unity
+{
+    public class FooMonoComposable : MonoComposable
+    {
+        private int _value = 12;
+
+        protected override IAspect[] GetAspects()
+        {
+            IAspect[] aspects = ArrayPool<IAspect>.GetPool(1).Get();
+            aspects[0] = new FooAspect(_value);
+            return aspects;
+        }
+    }
+}
+#endif

Tests/CompositionTests/Unity/MonoComposableTests.cs

@@ -0,0 +1,130 @@
+#if UNITY_2019_1_OR_NEWER
+using Gum.Composer;
+using Gum.Composer.Exception;
+using Gum.Composer.Unity.Runtime;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace Tests.CompositionTests.Unity
+{
+    public class MonoComposableTests
+    {
+        private MonoComposable _mockMonoComposable;
+
+        private const int VALUE = 12;
+
+        [SetUp]
+        public void SetUp()
+        {
+            GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            FooMonoComposable fooMonoComposable = cube.AddComponent<FooMonoComposable>();
+            _mockMonoComposable = fooMonoComposable;
+        }
+
+        [Test]
+        public void Add_Aspect_To_MonoComposable()
+        {
+            Assert.IsFalse(_mockMonoComposable.Composition.HasAspect(BarAspect.ASPECT_TYPE));
+            
+            _mockMonoComposable.Composition.AddAspect(new BarAspect(VALUE));
+            
+            Assert.IsTrue(_mockMonoComposable.Composition.HasAspect(BarAspect.ASPECT_TYPE));
+        }
+
+        [Test]
+        public void MonoComposable_Has_Aspect()
+        {
+            Assert.IsTrue(_mockMonoComposable.Composition.HasAspect(FooAspect.ASPECT_TYPE));
+        }
+        
+        [Test]
+        public void Get_Aspect_From_MonoComposable()
+        {
+            FooAspect fooAspect = _mockMonoComposable.Composition.GetAspect<FooAspect>();
+            Assert.AreEqual(VALUE, fooAspect.MyInt);
+        }
+
+        [Test]
+        public void Try_Get_Aspect_From_MonoComposable()
+        {
+            Assert.IsTrue(_mockMonoComposable.Composition.TryGetAspect(out FooAspect fooAspect));
+            Assert.AreEqual(VALUE, fooAspect.MyInt);
+            Assert.IsFalse(_mockMonoComposable.Composition.TryGetAspect(out BarAspect _));
+        }
+
+        [Test]
+        public void Get_Aspect_Fluent()
+        {
+            _mockMonoComposable.Composition.GetAspectFluent(out FooAspect fooAspect);
+            
+            Assert.AreEqual(VALUE, fooAspect.MyInt);
+        }
+
+        [Test]
+        public void Get_Aspect_With_Indexer()
+        {
+            _mockMonoComposable.Composition.AddAspect(new BarAspect(VALUE));
+            BarAspect barAspect = (BarAspect)_mockMonoComposable.Composition[BarAspect.ASPECT_TYPE];
+            
+            Assert.IsNotNull(barAspect);
+            Assert.AreEqual(VALUE, barAspect.MyInt);
+        }
+
+        [Test]
+        public void Set_Aspect()
+        {
+            FooAspect fooAspect = _mockMonoComposable.Composition.GetAspect<FooAspect>();
+            
+            Assert.AreEqual(VALUE, fooAspect.MyInt);
+
+            const int newValue = 20;
+            _mockMonoComposable.Composition.SetAspect(new FooAspect(newValue));
+            Assert.AreEqual(newValue, _mockMonoComposable.Composition.GetAspect<FooAspect>().MyInt);
+            Assert.AreEqual(1, _mockMonoComposable.Composition.AspectCount);
+        }
+        
+        [Test]
+        public void Set_Non_Existing_Aspect()
+        {
+            Assert.IsFalse(_mockMonoComposable.Composition.HasAspect(BarAspect.ASPECT_TYPE));
+
+            const int newValue = 20;
+            _mockMonoComposable.Composition.SetAspect(new BarAspect(newValue));
+            
+            Assert.AreEqual(newValue, _mockMonoComposable.Composition.GetAspect<BarAspect>().MyInt);
+            Assert.AreEqual(VALUE, _mockMonoComposable.Composition.GetAspect<FooAspect>().MyInt);
+            
+            Assert.AreEqual(2, _mockMonoComposable.Composition.AspectCount);
+        }
+
+        [Test]
+        public void Remove_Aspect()
+        {
+            Assert.IsTrue(_mockMonoComposable.Composition.HasAspect(FooAspect.ASPECT_TYPE));
+
+            _mockMonoComposable.Composition.RemoveAspect(FooAspect.ASPECT_TYPE);
+            
+            Assert.IsFalse(_mockMonoComposable.Composition.HasAspect(FooAspect.ASPECT_TYPE));
+        }
+
+        [Test]
+        public void Enumerator()
+        {
+            _mockMonoComposable.Composition.AddAspect(new BarAspect(VALUE));
+
+            foreach (IAspect aspect in _mockMonoComposable.Composition)
+            {
+                Assert.IsTrue(aspect is BarAspect || aspect is FooAspect);
+            }
+            
+            Assert.Pass();
+        }
+        
+        [TearDown]
+        public void TearDown()
+        {
+            Object.Destroy(_mockMonoComposable.gameObject);
+        }
+    }
+}
+#endif