UPdated all config settings to use objects to make everything optional instead of opinionated like this project started. Compiles but haven't tested anything.

Author: ProgrammerAL

src/CodeUpdater/CodeUpdater/CompileRunner.cs

@@ -13,10 +13,16 @@
 namespace ProgrammerAL.Tools.CodeUpdater;
 public class CompileRunner(ILogger Logger, IRunProcessHelper RunProcessHelper)
 {
-    public async ValueTask<CompileResults> CompileProjectsAsync(UpdateWork updateWork, string npmBuildCommand)
+    public async ValueTask<CompileResults> CompileProjectsAsync(UpdateWork updateWork, UpdateOptions updateOptions)
     {
         var csharpBuildResults = await CompileAllCSharpProjectsAsync(updateWork);
-        var npmDirectoryBuildResults = await BuildAllNpmDirectoriesAsync(updateWork, npmBuildCommand);
+
+        var npmBuildCommand = updateOptions.NpmOptions?.NpmBuildCommand;
+        var npmDirectoryBuildResults = new CompileNpmDirectoryResults(ImmutableArray<CompileNpmDirectoryResult>.Empty);
+        if (!string.IsNullOrWhiteSpace(npmBuildCommand))
+        {
+            npmDirectoryBuildResults = await BuildAllNpmDirectoriesAsync(updateWork, npmBuildCommand);
+        }
 
         return new CompileResults(csharpBuildResults, npmDirectoryBuildResults);
     }

src/CodeUpdater/CodeUpdater/Options/UpdateOptions.cs

@@ -1,11 +1,5 @@
 
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.ComponentModel.DataAnnotations;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace ProgrammerAL.Tools.CodeUpdater;
 
@@ -28,51 +22,72 @@ public class UpdateOptions
     public required IEnumerable<string> IgnorePatterns { get; set; }
 
     /// <summary>
-    /// Npm command to run to \"compile\" the npm directory. Format run is: npm run <NpmBuildCommand>.
+    /// Options for updating C# projects and code
+    /// </summary>
+    public CSharpOptions? CSharpOptions { get; set; }
+
+    /// <summary>
+    /// Options for updating Npm packages
+    /// </summary>
+    public NpmOptions? NpmOptions { get; set; }
+
+    /// <summary>
+    /// Options for output logging of the operation
+    /// </summary>
+    public LoggingOptions? LoggingOptions { get; set; }
+}
+
+public class NpmOptions
+{
+    /// <summary>
+    /// Npm command to \"compile\" the npm directory. Format run is: npm run <NpmBuildCommand>.
     /// </summary>
     [Required(AllowEmptyStrings = false)]
     public required string NpmBuildCommand { get; set; }
+}
 
-    public DotNetVersioningOptions? DotNetVersioningOptions { get; set; }
-
-    public DotNetAnalyzerOptions? DotNetAnalyzerOptions { get; set; }
+public class CSharpOptions
+{
+    /// <summary>
+    /// Versioning options for csproj files
+    /// </summary>
+    public CsProjVersioningOptions? CsProjVersioningOptions { get; set; }
 
     /// <summary>
-    /// Settings to use for configuring Nuget Audit settings in csproj files.
-    /// You can read more at https://learn.microsoft.com/en-us/nuget/concepts/auditing-packages#configuring-nuget-audit
+    /// Analyzers that are set in the csproj files
     /// </summary>
-    public NugetAuditOptions? NugetAudit { get; set; }
+    public CsProjDotNetAnalyzerOptions? CsProjDotNetAnalyzerOptions { get; set; }
 
     /// <summary>
-    /// True to run the `dotnet format` command
+    /// Options for any code styling updates that will be performed over C# code
     /// </summary>
-    [Required]
-    public required bool RunDotnetFormat { get; set; }
+    public CSharpStyleOptions? CSharpStyleOptions { get; set; }
 
     /// <summary>
-    /// If this is set, it will be the file to write logs to, in addition to the console
+    /// Settings to use for configuring Nuget Audit settings in csproj files.
+    /// You can read more at https://learn.microsoft.com/en-us/nuget/concepts/auditing-packages#configuring-nuget-audit
     /// </summary>
-    public string? OutputFile { get; set; }
+    public NugetAuditOptions? NugetAudit { get; set; }
 
     /// <summary>
-    /// Verbosity level to log. Valid values are: Verbose, Info, Warn, Error. Default value: verbose.
+    /// Settings to use for updating NuGet packages in csproj files
     /// </summary>
-    public string? LogLevel { get; set; } = "verbose";
+    public NuGetUpdateOptions? NuGetUpdates { get; set; }
 }
 
-public class DotNetVersioningOptions
+public class CsProjVersioningOptions
 {
     /// <summary>
     /// Target Framework to set in all *.csproj files
     /// </summary>
     [Required(AllowEmptyStrings = false)]
-    public required string DotNetTargetFramework { get; set; }
+    public required string TargetFramework { get; set; }
 
     /// <summary>
     /// C# language version to set in all *.csproj files
     /// </summary>
     [Required(AllowEmptyStrings = false)]
-    public required string DotNetLangVersion { get; set; }
+    public required string LangVersion { get; set; }
 
     /// <summary>
     /// The value to set for the TreatWarningsAsErrors flag in all *.csproj files
@@ -81,7 +96,7 @@ public class DotNetVersioningOptions
     public required bool TreatWarningsAsErrors { get; set; }
 }
 
-public class DotNetAnalyzerOptions
+public class CsProjDotNetAnalyzerOptions
 {
     /// <summary>
     /// True to set the `EnableNetAnalyzers` csproj value to true, false to set it to false
@@ -96,6 +111,15 @@ public class DotNetAnalyzerOptions
     public required bool EnforceCodeStyleInBuild { get; set; }
 }
 
+public class CSharpStyleOptions
+{
+    /// <summary>
+    /// True to run the `dotnet format` command
+    /// </summary>
+    [Required]
+    public required bool RunDotnetFormat { get; set; }
+}
+
 public class NugetAuditOptions
 {
     /// <summary>
@@ -107,12 +131,42 @@ public class NugetAuditOptions
     /// <summary>
     /// What value to set for the `NuGetAuditMode` property in the csproj file. Valid values are `direct` and `all`.
     /// </summary>
-    [Required]
+    [Required(AllowEmptyStrings = false)]
     public required string AuditMode { get; set; }
 
     /// <summary>
     /// What value to set for the `NuGetAuditLevel` property in the csproj file. Valid values are: `low`, `moderate`, `high`, and `critical`
     /// </summary>
-    [Required]
+    [Required(AllowEmptyStrings = false)]
     public required string AuditLevel { get; set; }
 }
+
+public class NuGetUpdateOptions
+{
+    /// <summary>
+    /// True to updates all referenced nugets to the latest version. These are the references in the csproj files.
+    /// </summary>
+    [Required]
+    public bool UpdateTopLevelNugetsInCsProj { get; set; }
+
+    /// <summary>
+    /// True to updates all indirect nugets to the latest version. These are the nugets that are referenced automatically based on SDK chosen or something like that.
+    /// </summary>
+    [Required]
+    public bool UpdateTopLevelNugetsNotInCsProj { get; set; }
+}
+
+public class LoggingOptions
+{
+    /// <summary>
+    /// If this is set, it will be the file to write logs to, in addition to the console
+    /// </summary>
+    [Required(AllowEmptyStrings = false)]
+    public required string OutputFile { get; set; }
+
+    /// <summary>
+    /// Verbosity level to log. Valid values are: Verbose, Info, Warn, Error. Default value: verbose.
+    /// </summary>
+    [Required(AllowEmptyStrings = false)]
+    public required string LogLevel { get; set; } = "verbose";
+}

src/CodeUpdater/CodeUpdater/Program.cs

@@ -49,7 +49,7 @@ static async ValueTask RunAsync(CommandOptions commandOptions)
     //After updating everything, compile all projects
     //  Don't do this in the above loop in case a project needs an update that would cause it to not compile
     //  So wait for all projects to be updated
-    var compileResults = await compileRunner.CompileProjectsAsync(updateWork, updateOptions.NpmBuildCommand);
+    var compileResults = await compileRunner.CompileProjectsAsync(updateWork, updateOptions);
 
     OutputSummary(updateWork, csUpdates, npmUpdates, compileResults, logger);
 }
@@ -59,25 +59,28 @@ static ILogger SetupLogger(UpdateOptions updateOptions)
     var loggerConfig = new LoggerConfiguration()
         .WriteTo.Console();
 
-    if (!string.IsNullOrWhiteSpace(updateOptions.OutputFile))
+    if (updateOptions.LoggingOptions is object)
     {
-        loggerConfig = loggerConfig.WriteTo.File(updateOptions.OutputFile);
-    }
+        if (!string.IsNullOrWhiteSpace(updateOptions.LoggingOptions.OutputFile))
+        {
+            loggerConfig = loggerConfig.WriteTo.File(updateOptions.LoggingOptions.OutputFile);
+        }
 
-    if (string.IsNullOrWhiteSpace(updateOptions.LogLevel))
-    {
-        loggerConfig = loggerConfig.MinimumLevel.Verbose();
-    }
-    else
-    {
-        loggerConfig = updateOptions.LogLevel.ToLower() switch
+        if (string.IsNullOrWhiteSpace(updateOptions.LoggingOptions.LogLevel))
+        {
+            loggerConfig = loggerConfig.MinimumLevel.Verbose();
+        }
+        else
         {
-            "verbose" => loggerConfig.MinimumLevel.Verbose(),
-            "info" => loggerConfig.MinimumLevel.Information(),
-            "warn" => loggerConfig.MinimumLevel.Warning(),
-            "error" => loggerConfig.MinimumLevel.Error(),
-            _ => loggerConfig.MinimumLevel.Verbose(),
-        };
+            loggerConfig = updateOptions.LoggingOptions.LogLevel.ToLower() switch
+            {
+                "verbose" => loggerConfig.MinimumLevel.Verbose(),
+                "info" => loggerConfig.MinimumLevel.Information(),
+                "warn" => loggerConfig.MinimumLevel.Warning(),
+                "error" => loggerConfig.MinimumLevel.Error(),
+                _ => loggerConfig.MinimumLevel.Verbose(),
+            };
+        }
     }
 
     Log.Logger = loggerConfig.CreateLogger();

src/CodeUpdater/CodeUpdater/Updaters/CSharpUpdater.cs

@@ -1,10 +1,6 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
+using System.Collections.Immutable;
 
 using ProgrammerAL.Tools.CodeUpdater.Helpers;
-using ProgrammerAL.Tools.CodeUpdater.Options;
 
 using Serilog;
 
@@ -29,20 +25,26 @@ public CSharpUpdater(
         _runProcessHelper = runProcessHelper;
         _updateOptions = updateOptions;
         _nugetUpdater = new NugetUpdater(_logger, _runProcessHelper);
-        _csProjUpdater = new CsProjUpdater(_logger, updateOptions);
-        _csCodeUpdater = new CsCodeUpdater(_logger, _runProcessHelper, updateOptions);
+        _csProjUpdater = new CsProjUpdater(_logger);
+        _csCodeUpdater = new CsCodeUpdater(_logger, _runProcessHelper);
     }
 
     public async ValueTask<ImmutableArray<CSharpUpdateResult>> UpdateAllCSharpProjectsAsync(UpdateWork updateWork)
     {
+        if (_updateOptions.CSharpOptions is null)
+        {
+            _logger.Information("No C# options provided, skipping C# updates");
+            return ImmutableArray<CSharpUpdateResult>.Empty;
+        }
+
         var builder = ImmutableArray.CreateBuilder<CSharpUpdateResult>();
         foreach (var csProjFilePath in updateWork.CsProjectFiles)
         {
             _logger.Information($"Updating '{csProjFilePath}'");
 
-            var csProjUpdates = UpdateCsProjPropertyValues(csProjFilePath);
-            var nugetUpdates = await UpdateNugetPackagesAsync(csProjFilePath);
-            var dotnetFormatUpdate = await RunDotnetFormatAsync(csProjFilePath);
+            var csProjUpdates = UpdateCsProjPropertyValues(csProjFilePath, _updateOptions.CSharpOptions);
+            var dotnetFormatUpdate = await RunDotnetFormatAsync(csProjFilePath, _updateOptions.CSharpOptions);
+            var nugetUpdates = await UpdateNugetPackagesAsync(csProjFilePath, _updateOptions.CSharpOptions);
 
             builder.Add(new CSharpUpdateResult(
                 csProjFilePath,
@@ -55,11 +57,17 @@ public async ValueTask<ImmutableArray<CSharpUpdateResult>> UpdateAllCSharpProjec
         return builder.ToImmutableArray();
     }
 
-    private async ValueTask<NugetUpdateResults> UpdateNugetPackagesAsync(string csProjFilePath)
+    private async ValueTask<NugetUpdateResults> UpdateNugetPackagesAsync(string csProjFilePath, CSharpOptions cSharpOptions)
     {
         try
         {
-            return await _nugetUpdater.UpdateNugetPackagesAsync(csProjFilePath);
+            if (cSharpOptions.NuGetUpdates is null)
+            {
+                _logger.Information("No NuGet options provided, skipping NuGet updates");
+                return new NugetUpdateResults(RetrievedPackageListSuccessfully: true, ImmutableArray<NugetUpdateResult>.Empty);
+            }
+
+            return await _nugetUpdater.UpdateNugetPackagesAsync(csProjFilePath, cSharpOptions.NuGetUpdates);
         }
         catch (Exception ex)
         {
@@ -68,11 +76,13 @@ private async ValueTask<NugetUpdateResults> UpdateNugetPackagesAsync(string csPr
         }
     }
 
-    private CsProjUpdateResult UpdateCsProjPropertyValues(string csProjFilePath)
+    private CsProjUpdateResult UpdateCsProjPropertyValues(string csProjFilePath, CSharpOptions cSharpOptions)
     {
         try
         {
-            return _csProjUpdater.UpdateCsProjPropertyValues(csProjFilePath);
+            return _csProjUpdater.UpdateCsProjPropertyValues(
+                csProjFilePath,
+                cSharpOptions);
         }
         catch (Exception ex)
         {
@@ -81,11 +91,17 @@ private CsProjUpdateResult UpdateCsProjPropertyValues(string csProjFilePath)
         }
     }
 
-    private async Task<DotnetFormatResult> RunDotnetFormatAsync(string csProjFilePath)
+    private async Task<DotnetFormatResult> RunDotnetFormatAsync(string csProjFilePath, CSharpOptions cSharpOptions)
     {
         try
         {
-            return await _csCodeUpdater.RunDotnetFormatAsync(csProjFilePath);
+            if (cSharpOptions.CSharpStyleOptions is null)
+            { 
+                _logger.Information("No C# style options provided, skipping dotnet format");
+                return new DotnetFormatResult(csProjFilePath, DotnetFormatResultType.DidNotRun);
+            }
+
+            return await _csCodeUpdater.RunDotnetFormatAsync(csProjFilePath, cSharpOptions.CSharpStyleOptions);
         }
         catch (Exception ex)
         {

src/CodeUpdater/CodeUpdater/Updaters/CsCodeUpdater.cs

@@ -1,22 +1,15 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.Xml.Linq;
-
+
 using ProgrammerAL.Tools.CodeUpdater.Helpers;
 
 using Serilog;
 
 namespace ProgrammerAL.Tools.CodeUpdater.Updaters;
 
-public class CsCodeUpdater(ILogger Logger, IRunProcessHelper RunProcessHelper, UpdateOptions UpdateOptions)
+public class CsCodeUpdater(ILogger Logger, IRunProcessHelper RunProcessHelper)
 {
-    public async ValueTask<DotnetFormatResult> RunDotnetFormatAsync(string csProjFilePath)
+    public async ValueTask<DotnetFormatResult> RunDotnetFormatAsync(string csProjFilePath, CSharpStyleOptions cSharpStyleOptions)
     {
-        if (!UpdateOptions.RunDotnetFormat)
+        if (!cSharpStyleOptions.RunDotnetFormat)
         {
             return new DotnetFormatResult(csProjFilePath, DotnetFormatResultType.DidNotRun);
         }