Added extension method to generate a descriptive system group heirarc…

…hy (#6)

Arch.SystemGroups.Tests/DescriptorTests/DescriptorTests.cs

@@ -0,0 +1,45 @@
+using Arch.SystemGroups.DefaultSystemGroups;
+using Arch.SystemGroups.Descriptors;
+using Arch.SystemGroups.Tests.NestedGroups;
+using Arch.SystemGroups.Tests.TestSetup1;
+using NSubstitute;
+
+namespace Arch.SystemGroups.Tests.DescriptorTests;
+
+public class DescriptorTests
+{
+    private ArchSystemsWorldBuilder<TestWorld> _worldBuilder;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _worldBuilder = new ArchSystemsWorldBuilder<TestWorld>(new TestWorld(), Substitute.For<IPlayerLoop>());
+        SystemGroups.InitSystemGroupSystemTest.InjectToWorld(ref _worldBuilder);
+        PhysicsSystemGroupSystemTest.InjectToWorld(ref _worldBuilder);
+        PostPhysicsSystemGroupSystemTest.InjectToWorld(ref _worldBuilder);
+        PostRenderingSystemGroupSystemTest.InjectToWorld(ref _worldBuilder);
+        PresentationSystemGroupSystemTest.InjectToWorld(ref _worldBuilder);
+        SimulationSystemGroupSystemTest.InjectToWorld(ref _worldBuilder);
+    }
+
+    [Test]
+    [TestCase(nameof(InitializationSystemGroup))]
+    [TestCase(nameof(PhysicsSystemGroup))]
+    [TestCase(nameof(PostPhysicsSystemGroup))]
+    [TestCase(nameof(PostRenderingSystemGroup))]
+    [TestCase(nameof(SimulationSystemGroup))]
+    public void CreatesSystemDescriptorInEachGroup(string group)
+    {
+        var systemGroupWorld = _worldBuilder.Finish();
+        var descriptor = systemGroupWorld.GenerateDescriptors();
+        Assert.That(descriptor.Where(x => x.Name == group).Count(), Is.EqualTo(1));
+    }
+
+    [Test]
+    public void CreatesAllSystemDescriptors()
+    {
+        var systemGroupWorld = _worldBuilder.Finish();
+        var descriptor = systemGroupWorld.GenerateDescriptors();
+        Assert.That(descriptor.Count, Is.EqualTo(6));
+    }
+}

Arch.SystemGroups.Tests/DescriptorTests/NestedDescriptorTests.cs

@@ -0,0 +1,34 @@
+using Arch.SystemGroups.DefaultSystemGroups;
+using Arch.SystemGroups.Descriptors;
+using Arch.SystemGroups.Tests.NestedGroups;
+using Arch.SystemGroups.Tests.TestSetup1;
+using NSubstitute;
+
+namespace Arch.SystemGroups.Tests.DescriptorTests;
+
+public class NestedDescriptorTests
+{
+    private ArchSystemsWorldBuilder<TestWorld> _worldBuilder;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _worldBuilder = new ArchSystemsWorldBuilder<TestWorld>(new TestWorld(), Substitute.For<IPlayerLoop>());
+        SystemInNestedGroup.InjectToWorld(ref _worldBuilder);
+    }
+    [Test]
+    public void NestedSystemGroupsAreCreated()
+    {
+        var systemGroupWorld = _worldBuilder.Finish();
+        var simulationSystemGroup =
+            systemGroupWorld.GenerateDescriptors().FirstOrDefault(x => x.Name == nameof(SimulationSystemGroup));
+        var root = simulationSystemGroup.Groups.First();
+        var firstLevel = root.Groups.First();
+        var secondLevel = firstLevel.Groups.First();
+
+        Assert.That(root.Name, Is.EqualTo(nameof(RootGroup)));
+        Assert.That(firstLevel.Name, Is.EqualTo(nameof(NestedGroup1)));
+        Assert.That(secondLevel.Name, Is.EqualTo(nameof(NestedGroup2)));
+        Assert.That(secondLevel.Systems.First().Name, Is.EqualTo(nameof(SystemInNestedGroup)));
+    }
+}

Arch.SystemGroups.Tests/DescriptorTests/SystemGroups/InitSystemGroupSystemTest.cs

@@ -0,0 +1,14 @@
+using Arch.System;
+using Arch.SystemGroups.DefaultSystemGroups;
+using Arch.SystemGroups.Tests.TestSetup1;
+
+namespace Arch.SystemGroups.Tests.DescriptorTests.SystemGroups
+{
+    [UpdateInGroup(typeof(InitializationSystemGroup))]
+    public partial class InitSystemGroupSystemTest : BaseSystem<TestWorld, float>
+    {
+        public InitSystemGroupSystemTest(TestWorld world) : base(world)
+        {
+        }
+    }
+}

Arch.SystemGroups.Tests/DescriptorTests/SystemGroups/PhysicsSystemGroupSystemTest.cs

@@ -0,0 +1,14 @@
+using Arch.System;
+using Arch.SystemGroups.DefaultSystemGroups;
+using Arch.SystemGroups.Tests.TestSetup1;
+
+namespace Arch.SystemGroups.Tests.DescriptorTests
+{
+    [UpdateInGroup(typeof(PhysicsSystemGroup))]
+    public partial class PhysicsSystemGroupSystemTest : BaseSystem<TestWorld, float>
+    {
+        public PhysicsSystemGroupSystemTest(TestWorld world) : base(world)
+        {
+        }
+    }
+}

Arch.SystemGroups.Tests/DescriptorTests/SystemGroups/PostPhysicsSystemGroupSystemTest.cs

@@ -0,0 +1,14 @@
+using Arch.System;
+using Arch.SystemGroups.DefaultSystemGroups;
+using Arch.SystemGroups.Tests.TestSetup1;
+
+namespace Arch.SystemGroups.Tests.DescriptorTests
+{
+    [UpdateInGroup(typeof(PostPhysicsSystemGroup))]
+    public partial class PostPhysicsSystemGroupSystemTest : BaseSystem<TestWorld, float>
+    {
+        public PostPhysicsSystemGroupSystemTest(TestWorld world) : base(world)
+        {
+        }
+    }
+}

Arch.SystemGroups.Tests/DescriptorTests/SystemGroups/PostRenderingSystemGroupSystemTest.cs

@@ -0,0 +1,14 @@
+using Arch.System;
+using Arch.SystemGroups.DefaultSystemGroups;
+using Arch.SystemGroups.Tests.TestSetup1;
+
+namespace Arch.SystemGroups.Tests.DescriptorTests
+{
+    [UpdateInGroup(typeof(PostRenderingSystemGroup))]
+    public partial class PostRenderingSystemGroupSystemTest : BaseSystem<TestWorld, float>
+    {
+        public PostRenderingSystemGroupSystemTest(TestWorld world) : base(world)
+        {
+        }
+    }
+}

Arch.SystemGroups.Tests/DescriptorTests/SystemGroups/PresentationSystemGroupSystemTest.cs

@@ -0,0 +1,14 @@
+using Arch.System;
+using Arch.SystemGroups.DefaultSystemGroups;
+using Arch.SystemGroups.Tests.TestSetup1;
+
+namespace Arch.SystemGroups.Tests.DescriptorTests
+{
+    [UpdateInGroup(typeof(PresentationSystemGroup))]
+    public partial class PresentationSystemGroupSystemTest : BaseSystem<TestWorld, float>
+    {
+        public PresentationSystemGroupSystemTest(TestWorld world) : base(world)
+        {
+        }
+    }
+}

Arch.SystemGroups.Tests/DescriptorTests/SystemGroups/SimulationSystemGroupSystemTest.cs

@@ -0,0 +1,14 @@
+using Arch.System;
+using Arch.SystemGroups.DefaultSystemGroups;
+using Arch.SystemGroups.Tests.TestSetup1;
+
+namespace Arch.SystemGroups.Tests.DescriptorTests
+{
+    [UpdateInGroup(typeof(SimulationSystemGroup))]
+    public partial class SimulationSystemGroupSystemTest : BaseSystem<TestWorld, float>
+    {
+        public SimulationSystemGroupSystemTest(TestWorld world) : base(world)
+        {
+        }
+    }
+}

Arch.SystemGroups/Descriptors/SystemDescriptor.cs

@@ -0,0 +1,26 @@
+/// <summary>
+/// 
+/// </summary>
+public struct SystemDescriptor
+{
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="name">Name of the system</param>
+    /// <param name="throttlingEnabled">Is throttling enabled for this system</param>
+    public SystemDescriptor(string name, bool throttlingEnabled)
+    {
+        Name = name;
+        ThrottlingEnabled = throttlingEnabled;
+    }
+
+    /// <summary>
+    /// Name of the system
+    /// </summary>
+    public string Name { get; }
+
+    /// <summary>
+    /// Is throttling enabled for this system
+    /// </summary>
+    public bool ThrottlingEnabled { get; }
+}

Arch.SystemGroups/Descriptors/SystemGroupDescriptor.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+
+namespace Arch.SystemGroups.Descriptors;
+
+    /// <summary>
+    /// Descriptor for a SystemGroup
+    /// </summary>
+    public struct SystemGroupDescriptor
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="name">name of the system group</param>
+        /// <param name="systems">a list of systems within this group</param>
+        /// <param name="groups">A list of subGroups within this group</param>
+        public SystemGroupDescriptor(string name, IReadOnlyList<SystemDescriptor> systems, IReadOnlyList<SystemGroupDescriptor> groups)
+        {
+            Name = name;
+            Systems = systems;
+            Groups = groups;
+        }
+
+        /// <summary>
+        /// Name of this SystemGroup
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// Systems within this group 
+        /// </summary>
+        public IReadOnlyList<SystemDescriptor> Systems { get; }
+
+        /// <summary>
+        /// Sub Groups within this group
+        /// </summary>
+        public IReadOnlyList<SystemGroupDescriptor> Groups { get; }
+    }

Arch.SystemGroups/Descriptors/SystemGroupWorldExtensions.cs

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using JetBrains.Annotations;
+
+namespace Arch.SystemGroups.Descriptors;
+
+/// <summary>
+/// Extensions for SystemGroupWorld
+/// </summary>
+public static class SystemGroupWorldExtensions
+{
+    /// <summary>
+    /// Generate the descriptor for the SystemGroupWorld
+    /// </summary>
+    /// <param name="world"></param>
+    [UsedImplicitly]
+    public static IReadOnlyList<SystemGroupDescriptor> GenerateDescriptors(this SystemGroupWorld world)
+    {
+        var descriptors = new List<SystemGroupDescriptor>();
+        // Foreach system group such as initialization, simulation, presentation
+        foreach (var worldSystemGroup in world.SystemGroups)
+        {
+            descriptors.Add(GenerateGroupDescriptor(worldSystemGroup.GetType().Name, worldSystemGroup.Nodes));
+        }
+
+        return descriptors;
+    }
+
+    /// <summary>
+    /// Generate the descriptor for the SystemGroup
+    /// </summary>
+    /// <param name="name">Name of the system group</param>
+    /// <param name="nodes">List of nodes within the system group</param>
+    private static SystemGroupDescriptor GenerateGroupDescriptor(string name, IReadOnlyList<ExecutionNode<float>> nodes)
+    {
+        var groupSystems = new List<SystemDescriptor>();
+        var groupNestedGroups = new List<SystemGroupDescriptor>();
+        GenerateNestedGroupDescriptors(nodes, groupSystems, groupNestedGroups);
+        return new SystemGroupDescriptor(name, groupSystems, groupNestedGroups
+        );
+    }
+
+    /// <summary>
+    /// Generate the descriptor for the SystemGroupWorld
+    /// </summary>
+    /// <param name="nodes"></param>
+    /// <param name="groupSystems"></param>
+    /// <param name="groupNestedGroups"></param>
+    /// <returns></returns>
+    private static void GenerateNestedGroupDescriptors(IReadOnlyList<ExecutionNode<float>> nodes,
+        List<SystemDescriptor> groupSystems, List<SystemGroupDescriptor> groupNestedGroups)
+    {
+        if(nodes is null) return;
+        foreach (var node in nodes)
+        {
+            if (node.IsGroup)
+            {
+                groupNestedGroups.Add(GenerateGroupDescriptor(node.CustomGroup.GetType().Name, node.CustomGroup.Nodes));
+            }
+            else
+            {
+                groupSystems.Add(new SystemDescriptor(node.System.GetType().Name, node.ThrottlingEnabled));
+            }
+        }
+    }
+}