PrintEnvironmentVariablesModule.cs (#500)

* PrintEnvironmentVariablesModule.cs
PrintGitInformationModule.cs

* ReleaseNotes.md

* Fix

* Fix

* IgnoreCycles

* MaxDepth = 2,

* [JsonIgnore] DirectoryInfo and FileInfo

* IgnoreReadOnlyProperties = true,

* IgnoreReadOnlyFields = true,

* Undo readonly properties

* WriteIndented = true,

* Fix json cyclical reference on folder.root

* [JsonConverter(typeof(FolderPathJsonConverter))]

* Git Info

* Fix

* Formatting Markdown

* WriteIndented = true,

* GetRealTypeName

---------

Co-authored-by: Tom Longhurst <[email protected]>

src/ModularPipelines.Build/Modules/PrintEnvironmentVariablesModule.cs

@@ -0,0 +1,24 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Extensions.Logging;
+using ModularPipelines.Context;
+using ModularPipelines.Modules;
+
+namespace ModularPipelines.Build.Modules;
+
+public class PrintEnvironmentVariablesModule : Module
+{
+    protected override async Task<IDictionary<string, object>?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+    {
+        await Task.CompletedTask;
+
+        context.Logger.LogInformation("Environment Variables: {EnvVars}", JsonSerializer.Serialize(context.Environment.EnvironmentVariables.GetEnvironmentVariables(), new JsonSerializerOptions
+        {
+            ReferenceHandler = ReferenceHandler.IgnoreCycles,
+            IgnoreReadOnlyFields = true,
+            WriteIndented = true,
+        }));
+
+        return null;
+    }
+}

src/ModularPipelines.Build/Modules/PrintGitInformationModule.cs

@@ -0,0 +1,25 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Extensions.Logging;
+using ModularPipelines.Context;
+using ModularPipelines.Git.Extensions;
+using ModularPipelines.Modules;
+
+namespace ModularPipelines.Build.Modules;
+
+public class PrintGitInformationModule : Module
+{
+    protected override async Task<IDictionary<string, object>?> ExecuteAsync(IPipelineContext context, CancellationToken cancellationToken)
+    {
+        await Task.CompletedTask;
+
+        context.Logger.LogInformation("Git Info: {GitInfo}", JsonSerializer.Serialize(context.Git().Information, new JsonSerializerOptions
+        {
+            ReferenceHandler = ReferenceHandler.IgnoreCycles,
+            IgnoreReadOnlyFields = true,
+            WriteIndented = true,
+        }));
+
+        return null;
+    }
+}

src/ModularPipelines.Build/Program.cs

@@ -45,6 +45,8 @@ await PipelineHostBuilder.Create()
             .AddModule<MergeCoverageModule>()
             .AddModule<ChangedFilesInPullRequestModule>()
             .AddModule<DependabotCommitsModule>()
+            .AddModule<PrintEnvironmentVariablesModule>()
+            .AddModule<PrintGitInformationModule>()
             .AddPipelineModuleHooks<MyModuleHooks>();
 
         collection.AddSingleton<IGitHubClient>(sp =>

src/ModularPipelines.Build/ReleaseNotes.md

@@ -1 +1,2 @@
-*   DependsOnAllModulesInheritingFromAttribute to allow a module to wait on all modules inheriting from a base without needing to list each module explicitly
+*   `[DependsOnAllModulesInheritingFromAttribute]` to allow a module to wait on all modules inheriting from a base without needing to list each module explicitly
+*   Better JSON serialization of `Folder` objects

src/ModularPipelines/Extensions/TypeExtensions.cs

@@ -1,9 +1,41 @@
-namespace ModularPipelines.Extensions;
+using System.Text;
+
+namespace ModularPipelines.Extensions;
 
 internal static class TypeExtensions
 {
     public static bool IsOrInheritsFrom(this Type type, Type otherType)
     {
         return type == otherType || type.IsSubclassOf(otherType);
     }
+
+    public static string GetRealTypeName(this Type type)
+    {
+        if (!type.IsGenericType)
+        {
+            return type.Name;
+        }
+
+        var stringBuilder = new StringBuilder();
+
+        stringBuilder.Append(type.Name.AsSpan(0, type.Name.IndexOf('`')));
+        stringBuilder.Append('<');
+
+        var appendComma = false;
+
+        foreach (var genericTypeArgument in type.GetGenericArguments())
+        {
+            if (appendComma)
+            {
+                stringBuilder.Append(',');
+            }
+
+            stringBuilder.Append(GetRealTypeName(genericTypeArgument));
+            appendComma = true;
+        }
+
+        stringBuilder.Append('>');
+
+        return stringBuilder.ToString();
+    }
 }

src/ModularPipelines/FileSystem/File.cs

@@ -1,9 +1,11 @@
 using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
 
 namespace ModularPipelines.FileSystem;
 
 public class File : IEquatable<File>
 {
+    [JsonIgnore]
     private readonly FileInfo _fileInfo;
 
     private FileInfo FileInfo

src/ModularPipelines/FileSystem/Folder.cs

@@ -1,11 +1,14 @@
 using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
 using Microsoft.Extensions.FileSystemGlobbing;
 using Microsoft.Extensions.FileSystemGlobbing.Abstractions;
+using ModularPipelines.JsonUtils;
 
 namespace ModularPipelines.FileSystem;
 
 public class Folder : IEquatable<Folder>
 {
+    [JsonIgnore]
     private readonly DirectoryInfo _directoryInfo;
 
     private DirectoryInfo DirectoryInfo
@@ -33,6 +36,7 @@ internal Folder(DirectoryInfo directoryInfo)
 
     public string Name => DirectoryInfo.Name;
 
+    [JsonConverter(typeof(FolderPathJsonConverter))]
     public Folder? Parent => DirectoryInfo.Parent;
 
     public string Path => DirectoryInfo.FullName;
@@ -45,7 +49,19 @@ public FileAttributes Attributes
         set => DirectoryInfo.Attributes = value;
     }
 
-    public Folder Root => DirectoryInfo.Root;
+    [JsonConverter(typeof(FolderPathJsonConverter))]
+    public Folder Root
+    {
+        get
+        {
+            if (DirectoryInfo.Root.FullName == Path)
+            {
+                return this;
+            }
+
+            return DirectoryInfo.Root;
+        }
+    }
 
     public DateTimeOffset CreationTime => DirectoryInfo.CreationTime;
 

src/ModularPipelines/JsonUtils/FolderPathJsonConverter.cs

@@ -0,0 +1,23 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using ModularPipelines.FileSystem;
+
+namespace ModularPipelines.JsonUtils;
+
+public class FolderPathJsonConverter : JsonConverter<Folder>
+{
+    public override Folder? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType == JsonTokenType.Null)
+        {
+            return null;
+        }
+
+        return new Folder(reader.GetString()!);
+    }
+
+    public override void Write(Utf8JsonWriter writer, Folder value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.Path);
+    }
+}

src/ModularPipelines/Modules/Module.cs

@@ -234,7 +234,7 @@ private void LogResult(T? executeResult)
 
         try
         {
-            Context.Logger.LogDebug("Module returned {Type}:", executeResult?.GetType().Name ?? typeof(T).Name);
+            Context.Logger.LogDebug("Module returned {Type}:", executeResult?.GetType().GetRealTypeName() ?? typeof(T).GetRealTypeName());
 
             if (executeResult is null)
             {
@@ -252,13 +252,13 @@ private void LogResult(T? executeResult)
             {
                 foreach (var o in enumerable.Cast<object>())
                 {
-                    Context.Logger.LogDebug("{Json}", JsonSerializer.Serialize(o, ModularPipelinesJsonSerializerSettings.Default));
+                    Context.Logger.LogDebug("{JsonUtils}", JsonSerializer.Serialize(o, ModularPipelinesJsonSerializerSettings.Default));
                 }
 
                 return;
             }
 
-            Context.Logger.LogDebug("{Json}", JsonSerializer.Serialize(executeResult));
+            Context.Logger.LogDebug("{JsonUtils}", JsonSerializer.Serialize(executeResult));
         }
         catch
         {

src/ModularPipelines/Serialization/ModularPipelinesJsonSerializerSettings.cs

@@ -8,5 +8,6 @@ internal static class ModularPipelinesJsonSerializerSettings
     public static readonly JsonSerializerOptions Default = new()
     {
         ReferenceHandler = ReferenceHandler.IgnoreCycles,
+        WriteIndented = true,
     };
 }