Add basic reactive system implementation (#5)

* Add basic reactive system implementation

Allows for basic observable triggering systems, this should have been implemented originally really but better late than never.

* Made recommended Codacity changes

Author: grofit

src/SystemRx.Tests.Infrastructure/SanityTests/DependencyInjectionSanityTests.cs

@@ -72,7 +72,7 @@ public void should_bind_and_resolve_framework_module(IDependencyRegistry registr
             var systems = resolver.ResolveAll<IConventionalSystemHandler>();
             Assert.NotNull(systems);
             Assert.NotEmpty(systems);
-            Assert.Equal(3, systems.Count());
+            Assert.Equal(4, systems.Count());
 
             var timeTracker = resolver.Resolve<ITimeTracker>();
             Assert.NotNull(timeTracker);

src/SystemsRx.Infrastructure/Modules/FrameworkModule.cs

@@ -20,6 +20,7 @@ public void Setup(IDependencyRegistry registry)
             registry.Bind<IConventionalSystemHandler, ManualSystemHandler>();
             registry.Bind<IConventionalSystemHandler, BasicSystemHandler>();
             registry.Bind<IConventionalSystemHandler, ReactToEventSystemHandler>();
+            registry.Bind<IConventionalSystemHandler, ReactiveSystemHandler>();
             registry.Bind<ISystemExecutor, SystemExecutor>();
             registry.Bind<IUpdateScheduler, DefaultUpdateScheduler>();
             registry.Bind<ITimeTracker>(x => x.ToBoundType(typeof(IUpdateScheduler)));

src/SystemsRx.Plugins.Transforms/Extensions/Transform2DExtensions.cs

@@ -6,9 +6,9 @@ namespace SystemsRx.Plugins.Transforms.Extensions
 {
     public static class Transform2DExtensions
     {
-        const float RadiansToDegrees = 180.0f / MathF.PI;
-        const float DegreesToRadians = MathF.PI / 180.0f;
-        const float Radian90Degrees = 90 * DegreesToRadians;
+        public static readonly float RadiansToDegrees = 180.0f / MathF.PI;
+        public static readonly float DegreesToRadians = MathF.PI / 180.0f;
+        public static readonly float Radian90Degrees = 90 * DegreesToRadians;
 
         /// <summary>
         /// Returns the transforms rotation but converted to degrees

src/SystemsRx.Plugins.Transforms/Extensions/VectorExtensions.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Numerics;
+
+namespace SystemsRx.Plugins.Transforms.Extensions
+{
+    public static class VectorExtensions
+    {
+        public static float ToAngle(this Vector2 vector)
+        { return MathF.Atan2(vector.Y, vector.X) * Transform2DExtensions.RadiansToDegrees; }
+    }
+}

src/SystemsRx.Tests/SystemsRx/Handlers/ReactiveSystemHandlerTests.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Linq;
+using NSubstitute;
+using SystemsRx.Events;
+using SystemsRx.Executor.Handlers.Conventional;
+using SystemsRx.MicroRx.Subjects;
+using SystemsRx.Systems;
+using SystemsRx.Systems.Conventional;
+using SystemsRx.Tests.Models;
+using SystemsRx.Tests.SystemsRx.Handlers.Helpers;
+using Xunit;
+
+namespace SystemsRx.Tests.SystemsRx.Handlers
+{
+    public class ReactiveSystemHandlerTests
+    {
+        public interface MultipleOfSameInterface : IReactiveSystem<int>, IReactiveSystem<float>
+        {
+
+        }
+        
+        [Fact]
+        public void should_correctly_handle_systems()
+        {
+            var reactiveSystemHandler = new ReactiveSystemHandler();
+            
+            var fakeMatchingSystem = Substitute.For<IReactiveSystem<int>>();
+            var fakeNonMatchingSystem1 = Substitute.For<ISystem>();
+            var fakeNonMatchingSystem2 = Substitute.For<ISystem>();
+            
+            Assert.True(reactiveSystemHandler.CanHandleSystem(fakeMatchingSystem));
+            Assert.False(reactiveSystemHandler.CanHandleSystem(fakeNonMatchingSystem1));
+            Assert.False(reactiveSystemHandler.CanHandleSystem(fakeNonMatchingSystem2));
+        }
+        
+        [Fact]
+        public void should_destroy_and_dispose_system()
+        {
+            var mockSystem = Substitute.For<IReactiveSystem<int>>();
+            var mockDisposable = Substitute.For<IDisposable>();
+            
+            var systemHandler = new ReactiveSystemHandler();
+            systemHandler._systemSubscriptions.Add(mockSystem, mockDisposable);
+            systemHandler.DestroySystem(mockSystem);
+            
+            mockDisposable.Received(1).Dispose();
+            Assert.Equal(0, systemHandler._systemSubscriptions.Count);
+        }
+
+        [Fact]
+        public void should_process_events_with_multiple_interfaces()
+        {
+            var dummyIntSubject = new Subject<int>();
+            var dummyFloatSubject = new Subject<float>();
+            
+            var mockSystem = Substitute.For<MultipleOfSameInterface>();
+            var dummyInt = 100;
+            var dummyFloat = 2.5f;
+
+            (mockSystem as IReactiveSystem<int>).ReactTo().Returns(dummyIntSubject);
+            (mockSystem as IReactiveSystem<float>).ReactTo().Returns(dummyFloatSubject);
+            
+            var systemHandler = new ReactiveSystemHandler();
+            systemHandler.SetupSystem(mockSystem);
+            dummyIntSubject.OnNext(dummyInt);
+            dummyFloatSubject.OnNext(dummyFloat);
+            
+            (mockSystem as IReactiveSystem<int>).Received(1).Execute(Arg.Is(dummyInt));
+            (mockSystem as IReactiveSystem<float>).Received(1).Execute(Arg.Is(dummyFloat));
+        }
+    }
+}

src/SystemsRx/Executor/Handlers/Conventional/ReactiveSystemHandler.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using SystemsRx.Attributes;
+using SystemsRx.Events;
+using SystemsRx.Extensions;
+using SystemsRx.MicroRx.Disposables;
+using SystemsRx.MicroRx.Extensions;
+using SystemsRx.Systems;
+using SystemsRx.Systems.Conventional;
+
+namespace SystemsRx.Executor.Handlers.Conventional
+{
+    [Priority(6)]
+    public class ReactiveSystemHandler : IConventionalSystemHandler
+    {
+        private readonly MethodInfo _setupSystemGenericMethodInfo;
+        public readonly IDictionary<ISystem, IDisposable> _systemSubscriptions;
+
+        public ReactiveSystemHandler()
+        {
+            _systemSubscriptions = new Dictionary<ISystem, IDisposable>();
+            _setupSystemGenericMethodInfo = typeof(ReactiveSystemHandler).GetMethod(nameof(SetupSystemGeneric));
+        }
+
+        public bool CanHandleSystem(ISystem system)
+        { return system.IsReactiveSystem(); }
+
+        public Type[] GetMatchingInterfaces(ISystem system)
+        { return system.GetGenericInterfacesFor(typeof(IReactiveSystem<>)).ToArray(); }
+        
+        public void SetupSystem(ISystem system)
+        {
+            var matchingInterfaces = GetMatchingInterfaces(system);
+            var disposables = new List<IDisposable>();
+            foreach (var matchingInterface in matchingInterfaces)
+            {
+                var dataType = matchingInterface.GetGenericArguments()[0];
+                var disposable = (IDisposable)_setupSystemGenericMethodInfo.MakeGenericMethod(dataType).Invoke(this, new object[] { system });
+                disposables.Add(disposable);
+            }
+            _systemSubscriptions.Add(system, new CompositeDisposable(disposables));
+        }
+
+        public IDisposable SetupSystemGeneric<T>(IReactiveSystem<T> system)
+        { return system.ReactTo().Subscribe(system.Execute); }
+        
+        public void DestroySystem(ISystem system)
+        { _systemSubscriptions.RemoveAndDispose(system); }
+
+        public void Dispose()
+        {
+            _systemSubscriptions.Values.DisposeAll();
+            _systemSubscriptions.Clear();
+        }
+    }
+}

src/SystemsRx/Extensions/ISystemExtensions.cs

@@ -37,5 +37,8 @@ public static IEnumerable<Type> GetGenericInterfaceType(this ISystem system, Typ
 
         public static bool IsReactToEventSystem(this ISystem system)
         { return system.MatchesSystemTypeWithGeneric(typeof(IReactToEventSystem<>)); }
+        
+        public static bool IsReactiveSystem(this ISystem system)
+        { return system.MatchesSystemTypeWithGeneric(typeof(IReactiveSystem<>)); }
     }
 }

src/SystemsRx/Systems/Conventional/IBasicSystem.cs

@@ -12,7 +12,7 @@ namespace SystemsRx.Systems.Conventional
     public interface IBasicSystem : ISystem
     {
         /// <summary>
-        /// The processor to handle the entity
+        /// The method to execute every update
         /// </summary>
         void Execute(ElapsedTime elapsedTime);
     }

src/SystemsRx/Systems/Conventional/IReactiveSystem.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace SystemsRx.Systems.Conventional
+{
+    public interface IReactiveSystem<T> : ISystem
+    {
+        /// <summary>
+        /// Returns and observable indicating when the system should execute
+        /// </summary>
+        /// <returns>Observable indicating when the system should execute</returns>
+        IObservable<T> ReactTo();
+        
+        /// <summary>
+        /// Thhe method to execute on triggering
+        /// </summary>
+        void Execute(T data);
+    }
+}