Refactor DependencyCollisionDetector.cs to work on pipeline start, no…

ModularPipelines.Build/Modules/LocalMachine/UploadPackagesToLocalNuGetModule.cs

@@ -18,7 +18,7 @@ protected override async Task OnBeforeExecute(IModuleContext context)
 
         foreach (var packagePath in packagePaths.Value!)
         {
-            context.Logger.LogInformation("Uploading {File}", packagePath);
+            context.Logger.LogInformation("[Local Directory] Uploading {File}", packagePath);
         }
 
         await base.OnBeforeExecute(context);

ModularPipelines.Examples/Modules/DependentOn2.cs

@@ -0,0 +1,16 @@
+using ModularPipelines.Attributes;
+using ModularPipelines.Context;
+using ModularPipelines.Models;
+using ModularPipelines.Modules;
+
+namespace ModularPipelines.Examples.Modules;
+
+[DependsOn<DependentOnSuccessModule>]
+public class DependentOn2 : Module
+{
+    protected override async Task<ModuleResult<IDictionary<string, object>>?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
+    {
+        await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken);
+        return null;
+    }
+}

ModularPipelines.Examples/Modules/DependentOn3.cs

@@ -0,0 +1,16 @@
+using ModularPipelines.Attributes;
+using ModularPipelines.Context;
+using ModularPipelines.Models;
+using ModularPipelines.Modules;
+
+namespace ModularPipelines.Examples.Modules;
+
+[DependsOn<DependentOn2>]
+public class DependentOn3 : Module
+{
+    protected override async Task<ModuleResult<IDictionary<string, object>>?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
+    {
+        await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken);
+        return null;
+    }
+}

ModularPipelines.Examples/Modules/DependentOn4.cs

@@ -0,0 +1,16 @@
+using ModularPipelines.Attributes;
+using ModularPipelines.Context;
+using ModularPipelines.Models;
+using ModularPipelines.Modules;
+
+namespace ModularPipelines.Examples.Modules;
+
+[DependsOn<DependentOn3>]
+public class DependentOn4 : Module
+{
+    protected override async Task<ModuleResult<IDictionary<string, object>>?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
+    {
+        await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken);
+        return null;
+    }
+}

ModularPipelines.Examples/Modules/DependentOnSuccessModule.cs

@@ -7,36 +7,6 @@ namespace ModularPipelines.Examples.Modules;
 
 [DependsOn<SuccessModule>]
 public class DependentOnSuccessModule : Module
-{
-    protected override async Task<ModuleResult<IDictionary<string, object>>?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
-    {
-        await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken);
-        return null;
-    }
-}
-
-[DependsOn<DependentOnSuccessModule>]
-public class DependentOn2 : Module
-{
-    protected override async Task<ModuleResult<IDictionary<string, object>>?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
-    {
-        await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken);
-        return null;
-    }
-}
-
-[DependsOn<DependentOn2>]
-public class DependentOn3 : Module
-{
-    protected override async Task<ModuleResult<IDictionary<string, object>>?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
-    {
-        await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken);
-        return null;
-    }
-}
-
-[DependsOn<DependentOn3>]
-public class DependentOn4 : Module
 {
     protected override async Task<ModuleResult<IDictionary<string, object>>?> ExecuteAsync(IModuleContext context, CancellationToken cancellationToken)
     {

ModularPipelines.UnitTests/DirectCollisionTests.cs

@@ -21,7 +21,7 @@ public void Modules_Dependent_On_Each_Other_Throws_Exception()
                 })
             .ExecutePipelineAsync(), 
             Throws.Exception.TypeOf<DependencyCollisionException>()
-                .With.Message.EqualTo("Dependency collision detected: **ModularPipelines.UnitTests.DirectCollisionTests+DependencyConflictModule2** -> ModularPipelines.UnitTests.DirectCollisionTests+DependencyConflictModule1 -> **ModularPipelines.UnitTests.DirectCollisionTests+DependencyConflictModule2**"));
+                .With.Message.EqualTo("Dependency collision detected: **DependencyConflictModule1** -> DependencyConflictModule2 -> **DependencyConflictModule1**"));
     }
 
     [DependsOn<DependencyConflictModule2>]

ModularPipelines.UnitTests/NestedCollisionTests.cs

@@ -24,7 +24,7 @@ public void Modules_Dependent_On_Each_Other_Throws_Exception()
                 })
                 .ExecutePipelineAsync(), 
             Throws.Exception.TypeOf<DependencyCollisionException>()
-                .With.Message.EqualTo("Dependency collision detected: **ModularPipelines.UnitTests.NestedCollisionTests+DependencyConflictModule5** -> ModularPipelines.UnitTests.NestedCollisionTests+DependencyConflictModule2 -> ModularPipelines.UnitTests.NestedCollisionTests+DependencyConflictModule3 -> ModularPipelines.UnitTests.NestedCollisionTests+DependencyConflictModule4 -> **ModularPipelines.UnitTests.NestedCollisionTests+DependencyConflictModule5**"));
+                .With.Message.EqualTo("Dependency collision detected: **DependencyConflictModule2** -> DependencyConflictModule3 -> DependencyConflictModule4 -> DependencyConflictModule5 -> **DependencyConflictModule2**"));
     }
 
     [DependsOn<DependencyConflictModule2>]

ModularPipelines/Context/Command.cs

@@ -11,7 +11,7 @@ namespace ModularPipelines.Context;
 internal class Command : ICommand
 {
     private readonly IModuleLoggerProvider _moduleLoggerProvider;
-    private ILogger Logger => _moduleLoggerProvider.Logger;
+    private ILogger Logger => _moduleLoggerProvider.GetLogger();
 
     public Command(IModuleLoggerProvider moduleLoggerProvider)
     {

ModularPipelines/Context/Downloader.cs

@@ -37,7 +37,7 @@ public async Task<File> DownloadFileAsync(DownloadOptions options, CancellationT
 
         await stream.CopyToAsync(newFile, cancellationToken);
 
-        _moduleLoggerProvider.Logger.LogInformation("File {Uri} downloaded to {SaveLocation}", options.DownloadUri, filePathToSave);
+        _moduleLoggerProvider.GetLogger().LogInformation("File {Uri} downloaded to {SaveLocation}", options.DownloadUri, filePathToSave);
 
         return filePathToSave!;
     }

ModularPipelines/Context/IModuleContext.cs

@@ -18,6 +18,7 @@ public interface IModuleContext
     public IOptions<PipelineOptions> PipelineOptions { get; }
     internal IDependencyCollisionDetector DependencyCollisionDetector { get; }
     internal IModuleResultRepository ModuleResultRepository { get; }
+    internal void FetchLogger(Type getType);
     public T? Get<T>();
     public ILogger Logger { get; }
 

ModularPipelines/Context/ModuleContext.cs

@@ -13,8 +13,9 @@ namespace ModularPipelines.Context;
 internal class ModuleContext : IModuleContext
 {
     private readonly IModuleLoggerProvider _moduleLoggerProvider;
+    private ILogger? _logger;
 
-    public ILogger Logger => _moduleLoggerProvider.Logger;
+    public ILogger Logger => _logger ?? _moduleLoggerProvider.GetLogger();
 
     public IServiceProvider ServiceProvider { get; }
 
@@ -36,6 +37,11 @@ internal class ModuleContext : IModuleContext
     public IHex Hex { get; }
     public IBase64 Base64 { get; }
 
+    public void FetchLogger(Type getType)
+    {
+        _logger = _moduleLoggerProvider.GetLogger(getType);
+    }
+
     public T Get<T>()
     {
         return (T) ServiceProvider.GetRequiredService(typeof(T));

ModularPipelines/Engine/DependencyChainProvider.cs

@@ -0,0 +1,48 @@
+using System.Reflection;
+using ModularPipelines.Attributes;
+using ModularPipelines.Models;
+using ModularPipelines.Modules;
+
+namespace ModularPipelines.Engine;
+
+internal class DependencyChainProvider : IDependencyChainProvider
+{
+    public IReadOnlyList<ModuleDependencyModel> ModuleDependencyModels { get; }
+
+    public DependencyChainProvider(IEnumerable<ModuleBase> modules)
+    {
+        ModuleDependencyModels = Detect(modules.Select(x => new ModuleDependencyModel(x)).ToList());
+    }
+
+    private List<ModuleDependencyModel> Detect(List<ModuleDependencyModel> allModules)
+    {
+        foreach (var moduleDependencyModel in allModules)
+        {
+            var dependencies = GetModuleDependencies(moduleDependencyModel, allModules).ToList();
+
+            moduleDependencyModel.IsDependentOn.AddRange(dependencies);
+
+            foreach (var dependencyModel in dependencies)
+            {
+                dependencyModel.IsDependencyFor.Add(moduleDependencyModel);
+            }
+        }
+
+        return allModules;
+    }
+
+    private IEnumerable<ModuleDependencyModel> GetModuleDependencies(ModuleDependencyModel moduleDependencyModel, IReadOnlyCollection<ModuleDependencyModel> allModules)
+    {
+        var customAttributes = moduleDependencyModel.Module.GetType().GetCustomAttributes<DependsOnAttribute>(true);
+
+        foreach (var dependsOnAttribute in customAttributes)
+        {
+            yield return GetModuleDependencyModel(dependsOnAttribute.Type, allModules);
+        }
+    }
+
+    private ModuleDependencyModel GetModuleDependencyModel(Type type, IEnumerable<ModuleDependencyModel> allModules)
+    {
+        return allModules.First(x => x.Module.GetType() == type);
+    }
+}

ModularPipelines/Engine/DependencyDetector.cs

@@ -1,82 +1,22 @@
-using System.Reflection;
-using System.Text;
-using Microsoft.Extensions.Logging;
-using ModularPipelines.Attributes;
-using ModularPipelines.Modules;
+using ModularPipelines.Helpers;
 
-namespace ModularPipelines;
+namespace ModularPipelines.Engine;
 
-public class DependencyDetector : IDependencyDetector
+internal class DependencyDetector : IDependencyDetector
 {
-    private readonly ILogger<DependencyDetector> _logger;
-    public IReadOnlyList<ModuleDependencyModel> ModuleDependencyModels { get; }
+    private readonly IDependencyCollisionDetector _dependencyCollisionDetector;
+    private readonly IDependencyPrinter _dependencyPrinter;
 
-    public DependencyDetector(IEnumerable<ModuleBase> modules, ILogger<DependencyDetector> logger)
+    public DependencyDetector(IDependencyCollisionDetector dependencyCollisionDetector,
+        IDependencyPrinter dependencyPrinter)
     {
-        _logger = logger;
-        ModuleDependencyModels = Detect(modules.Select(x => new ModuleDependencyModel(x)).ToList());
+        _dependencyCollisionDetector = dependencyCollisionDetector;
+        _dependencyPrinter = dependencyPrinter;
     }
 
-    public void Print()
+    public void Check()
     {
-        var stringBuilder = new StringBuilder();
-
-        foreach (var moduleDependencyModel in ModuleDependencyModels)
-        {
-            stringBuilder.AppendLine();
-            Print(stringBuilder, moduleDependencyModel, 1);
-        }
-
-        _logger.LogInformation("The following dependency chains have been detected:\r\n{Chain}", stringBuilder.ToString());
-    }
-
-    private void Print(StringBuilder stringBuilder, ModuleDependencyModel moduleDependencyModel, int i)
-    {
-        stringBuilder.Append(new string('-', i));
-        stringBuilder.Append(' ');
-        stringBuilder.AppendLine(moduleDependencyModel.Module.GetType().Name);
-
-        foreach (var dependencyModel in moduleDependencyModel.IsDependencyFor)
-        {
-            Print(stringBuilder, dependencyModel, i+2);
-        }
-    }
-
-    private List<ModuleDependencyModel> Detect(List<ModuleDependencyModel> allModules)
-    {
-        foreach (var moduleDependencyModel in allModules)
-        {
-            var dependencies = GetModuleDependencies(moduleDependencyModel, allModules).ToList();
-
-            moduleDependencyModel.IsDependentOn.AddRange(dependencies);
-
-            foreach (var dependencyModel in dependencies)
-            {
-                dependencyModel.IsDependencyFor.Add(moduleDependencyModel);
-            }
-        }
-
-        return allModules.Where(x => !x.IsDependentOn.Any()).ToList();
+        _dependencyCollisionDetector.CheckCollisions();
+        _dependencyPrinter.Print();
     }
-
-    private IEnumerable<ModuleDependencyModel> GetModuleDependencies(ModuleDependencyModel moduleDependencyModel, IReadOnlyCollection<ModuleDependencyModel> allModules)
-    {
-        var customAttributes = moduleDependencyModel.Module.GetType().GetCustomAttributes<DependsOnAttribute>(true);
-
-        foreach (var dependsOnAttribute in customAttributes)
-        {
-            yield return GetModuleDependencyModel(dependsOnAttribute.Type, allModules);
-        }
-    }
-
-    private ModuleDependencyModel GetModuleDependencyModel(Type type, IEnumerable<ModuleDependencyModel> allModules)
-    {
-        return allModules.First(x => x.Module.GetType() == type);
-    }
-}
-
-public record ModuleDependencyModel(ModuleBase Module)
-{
-    public List<ModuleDependencyModel> IsDependencyFor { get; } = new();
-    public List<ModuleDependencyModel> IsDependentOn { get; } = new();
 }

ModularPipelines/Engine/DependencyPrinter.cs

@@ -0,0 +1,42 @@
+using System.Text;
+using Microsoft.Extensions.Logging;
+using ModularPipelines.Models;
+
+namespace ModularPipelines.Engine;
+
+internal class DependencyPrinter : IDependencyPrinter
+{
+    private readonly IDependencyChainProvider _dependencyChainProvider;
+    private readonly ILogger<DependencyPrinter> _logger;
+
+    public DependencyPrinter(IDependencyChainProvider dependencyChainProvider, ILogger<DependencyPrinter> logger)
+    {
+        _dependencyChainProvider = dependencyChainProvider;
+        _logger = logger;
+    }
+
+    public void Print()
+    {
+        var stringBuilder = new StringBuilder();
+
+        foreach (var moduleDependencyModel in _dependencyChainProvider.ModuleDependencyModels)
+        {
+            stringBuilder.AppendLine();
+            Print(stringBuilder, moduleDependencyModel, 1);
+        }
+
+        _logger.LogInformation("The following dependency chains have been detected:\r\n{Chain}", stringBuilder.ToString());
+    }
+
+    private void Print(StringBuilder stringBuilder, ModuleDependencyModel moduleDependencyModel, int i)
+    {
+        stringBuilder.Append(new string('-', i));
+        stringBuilder.Append(' ');
+        stringBuilder.AppendLine(moduleDependencyModel.Module.GetType().Name);
+
+        foreach (var dependencyModel in moduleDependencyModel.IsDependencyFor)
+        {
+            Print(stringBuilder, dependencyModel, i+2);
+        }
+    }
+}

ModularPipelines/Engine/IDependencyChainProvider.cs

@@ -0,0 +1,8 @@
+using ModularPipelines.Models;
+
+namespace ModularPipelines.Engine;
+
+internal interface IDependencyChainProvider
+{
+    IReadOnlyList<ModuleDependencyModel> ModuleDependencyModels { get; }
+}

ModularPipelines/Engine/IDependencyDetector.cs

@@ -1,7 +1,6 @@
-namespace ModularPipelines;
+namespace ModularPipelines.Engine;
 
-public interface IDependencyDetector
-{
-    IReadOnlyList<ModuleDependencyModel> ModuleDependencyModels { get; }
-    void Print();
+internal interface IDependencyDetector
+{ 
+    void Check();
 }

ModularPipelines/Engine/IDependencyPrinter.cs

@@ -0,0 +1,6 @@
+namespace ModularPipelines.Engine;
+
+internal interface IDependencyPrinter
+{
+    void Print();
+}

ModularPipelines/Engine/IModuleResultPrinter.cs

@@ -1,6 +1,4 @@
-using ModularPipelines.Enums;
-
-namespace ModularPipelines.Engine;
+namespace ModularPipelines.Engine;
 
 public interface IModuleResultPrinter
 {