Add code analysis to detect missing using statements and finding fixes (#15)

richardsondev · web-flow · commit 740a0f5fe231 · 2024-09-12T18:13:13.000-07:00
Add code analysis scanning in build and fixes found warnings
diff --git a/src/.editorconfig b/src/.editorconfig
@@ -2,3 +2,10 @@
 
 # CS1591: Missing XML comment for publicly visible type or member
 dotnet_diagnostic.CS1591.severity = suggestion
+
+# Organize usings
+dotnet_sort_system_directives_first = true
+dotnet_separate_import_directive_groups = true
+
+# Missing usings should be reported as error (IDE0005)
+dotnet_diagnostic.IDE0005.severity = error
diff --git a/src/AggregateConfigBuildTask.sln b/src/AggregateConfigBuildTask.sln
@@ -12,6 +12,7 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{29D0AE56-C184-4741-824F-521198552928}"
 	ProjectSection(SolutionItems) = preProject
 		.editorconfig = .editorconfig
+		Directory.Build.props = Directory.Build.props
 		Directory.Packages.props = Directory.Packages.props
 	EndProjectSection
 EndProject
diff --git a/src/Contracts/Contracts.csproj b/src/Contracts/Contracts.csproj
@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>netstandard2.0</TargetFramework>
-        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <NoWarn>CA1027</NoWarn>
     </PropertyGroup>
 
 </Project>
diff --git a/src/Contracts/InputOutputEnums.cs b/src/Contracts/InputOutputEnums.cs
@@ -1,20 +1,20 @@
 ﻿namespace AggregateConfigBuildTask.Contracts
 {
-    public enum OutputTypeEnum
+    public enum OutputType
     {
-        Json,
-        Arm,
+        Json = 0,
+        Arm = 1,
         ArmParameter = Arm,
-        Yml,
+        Yml = 2,
         Yaml = Yml
     }
 
-    public enum InputTypeEnum
+    public enum InputType
     {
-        Json,
-        Arm,
+        Json = 0,
+        Arm = 1,
         ArmParameter = Arm,
-        Yml,
+        Yml = 2,
         Yaml = Yml
     }
 }
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
@@ -0,0 +1,13 @@
+<Project>
+
+  <PropertyGroup>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <Deterministic>true</Deterministic>
+    <EnableNETAnalyzers>true</EnableNETAnalyzers>
+    <AnalysisLevel>latest</AnalysisLevel>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <CodeAnalysisTreatWarningsAsErrors>false</CodeAnalysisTreatWarningsAsErrors>
+    <AnalysisMode>AllEnabledByDefault</AnalysisMode>
+  </PropertyGroup>
+
+</Project>
diff --git a/src/Directory.Packages.props b/src/Directory.Packages.props
@@ -25,6 +25,8 @@
   </ItemGroup>
   <!-- Global packages -->
   <ItemGroup>
+    <GlobalPackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="8.0.0" />
     <GlobalPackageReference Include="ReferenceTrimmer" Version="3.3.6" />
+    <GlobalPackageReference Include="Roslynator.Analyzers" Version="4.12.4" />
   </ItemGroup>
 </Project>
diff --git a/src/Task/AggregateConfig.cs b/src/Task/AggregateConfig.cs
@@ -26,7 +26,7 @@ public class AggregateConfig : Task
         [Required]
         public string OutputType { get; set; }
 
-        public bool AddSourceProperty { get; set; } = false;
+        public bool AddSourceProperty { get; set; }
 
         public string[] AdditionalProperties { get; set; }
 
@@ -48,18 +48,18 @@ public override bool Execute()
 
                 OutputFile = Path.GetFullPath(OutputFile);
 
-                if (!Enum.TryParse(OutputType, true, out OutputTypeEnum outputType) ||
-                    !Enum.IsDefined(typeof(OutputTypeEnum), outputType))
+                if (!Enum.TryParse(OutputType, true, out OutputType outputType) ||
+                    !Enum.IsDefined(typeof(OutputType), outputType))
                 {
-                    Log.LogError("Invalid OutputType: {0}. Available options: {1}", OutputType, string.Join(", ", Enum.GetNames(typeof(OutputTypeEnum))));
+                    Log.LogError("Invalid OutputType: {0}. Available options: {1}", OutputType, string.Join(", ", Enum.GetNames(typeof(OutputType))));
                     return false;
                 }
 
-                InputTypeEnum inputType = InputTypeEnum.Yaml;
+                InputType inputType = Contracts.InputType.Yaml;
                 if (!string.IsNullOrEmpty(InputType) &&
-                    (!Enum.TryParse(InputType, true, out inputType) || !Enum.IsDefined(typeof(InputTypeEnum), inputType)))
+                    (!Enum.TryParse(InputType, true, out inputType) || !Enum.IsDefined(typeof(InputType), inputType)))
                 {
-                    Log.LogError("Invalid InputType: {0}. Available options: {1}", InputType, string.Join(", ", Enum.GetNames(typeof(InputTypeEnum))));
+                    Log.LogError("Invalid InputType: {0}. Available options: {1}", InputType, string.Join(", ", Enum.GetNames(typeof(InputType))));
                     return false;
                 }
 
@@ -103,7 +103,7 @@ private void EmitHeader()
                 .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
                 .InformationalVersion;
 
-            Log.LogMessage($"AggregateConfig Version: {informationalVersion}");
+            Log.LogMessage(MessageImportance.High, $"AggregateConfig Version: {informationalVersion}");
         }
     }
 }
diff --git a/src/Task/AggregateConfigBuildTask.csproj b/src/Task/AggregateConfigBuildTask.csproj
@@ -2,13 +2,11 @@
 
     <PropertyGroup>
         <TargetFramework>netstandard2.0</TargetFramework>
-        <GenerateDocumentationFile>true</GenerateDocumentationFile>
         <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
-        <Deterministic>true</Deterministic>
         <PublishRepositoryUrl>true</PublishRepositoryUrl>
         <EmbedUntrackedSources>true</EmbedUntrackedSources>
         <SourceLinkCreate>true</SourceLinkCreate>
-        <NoWarn>NU5100</NoWarn>
+        <NoWarn>NU5100,CA1031,CA1819</NoWarn>
     </PropertyGroup>
 
     <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">
diff --git a/src/Task/FileHandlers/ArmParametersFileHandler.cs b/src/Task/FileHandlers/ArmParametersFileHandler.cs
@@ -8,19 +8,21 @@ namespace AggregateConfigBuildTask.FileHandlers
 {
     public class ArmParametersFileHandler : IOutputWriter, IInputReader
     {
-        readonly IFileSystem fileSystem;
+        private readonly IFileSystem fileSystem;
+
+        private readonly JsonSerializerOptions jsonOptions = new JsonSerializerOptions { WriteIndented = true };
 
         internal ArmParametersFileHandler(IFileSystem fileSystem)
         {
             this.fileSystem = fileSystem;
         }
 
         /// <inheritdoc/>
-        public ValueTask<JsonElement> ReadInput(string inputPath)
+        public async ValueTask<JsonElement> ReadInput(string inputPath)
         {
             using (var stream = fileSystem.OpenRead(inputPath))
             {
-                using (var jsonDoc = JsonDocument.Parse(stream))
+                using (var jsonDoc = await JsonDocument.ParseAsync(stream).ConfigureAwait(false))
                 {
                     if (jsonDoc.RootElement.TryGetProperty("parameters", out JsonElement parameters))
                     {
@@ -41,10 +43,10 @@ public ValueTask<JsonElement> ReadInput(string inputPath)
                         }
 
                         var modifiedJson = modifiedParameters.ToJsonString();
-                        return new ValueTask<JsonElement>(Task.FromResult(JsonSerializer.Deserialize<JsonElement>(modifiedJson)));
+                        return JsonSerializer.Deserialize<JsonElement>(modifiedJson);
                     }
 
-                    return new ValueTask<JsonElement>(Task.FromResult(jsonDoc.RootElement.Clone()));
+                    return jsonDoc.RootElement.Clone();
                 }
             }
         }
@@ -74,8 +76,6 @@ public void WriteOutput(JsonElement? mergedData, string outputPath)
                     ["contentVersion"] = "1.0.0.0",
                     ["parameters"] = parameters
                 };
-
-                var jsonOptions = new JsonSerializerOptions { WriteIndented = true };
                 var jsonContent = JsonSerializer.Serialize(armTemplate, jsonOptions);
                 fileSystem.WriteAllText(outputPath, jsonContent);
             }
@@ -90,7 +90,7 @@ public void WriteOutput(JsonElement? mergedData, string outputPath)
         /// </summary>
         /// <param name="value">The JsonElement value to evaluate.</param>
         /// <returns>A string representing the ARM template parameter type.</returns>
-        private string GetParameterType(JsonElement value)
+        private static string GetParameterType(JsonElement value)
         {
             switch (value.ValueKind)
             {
@@ -115,7 +115,7 @@ private string GetParameterType(JsonElement value)
             }
         }
 
-        private JsonNode ConvertElementToNode(JsonElement element)
+        private static JsonNode ConvertElementToNode(JsonElement element)
         {
             // Use GetRawText to get the JSON string representation of the JsonElement
             var jsonString = element.GetRawText();
diff --git a/src/Task/FileHandlers/FileHandlerFactory.cs b/src/Task/FileHandlers/FileHandlerFactory.cs
@@ -6,45 +6,45 @@ namespace AggregateConfigBuildTask.FileHandlers
 {
     public static class FileHandlerFactory
     {
-        internal static IOutputWriter GetOutputWriter(IFileSystem fileSystem, OutputTypeEnum format)
+        internal static IOutputWriter GetOutputWriter(IFileSystem fileSystem, OutputType format)
         {
             switch (format)
             {
-                case OutputTypeEnum.Json:
+                case OutputType.Json:
                     return new JsonFileHandler(fileSystem);
-                case OutputTypeEnum.Yaml:
+                case OutputType.Yaml:
                     return new YamlFileHandler(fileSystem);
-                case OutputTypeEnum.Arm:
+                case OutputType.Arm:
                     return new ArmParametersFileHandler(fileSystem);
                 default:
                     throw new ArgumentException("Unsupported format");
             }
         }
 
-        internal static IInputReader GetInputReader(IFileSystem fileSystem, InputTypeEnum format)
+        internal static IInputReader GetInputReader(IFileSystem fileSystem, InputType format)
         {
             switch (format)
             {
-                case InputTypeEnum.Yaml:
+                case InputType.Yaml:
                     return new YamlFileHandler(fileSystem);
-                case InputTypeEnum.Json:
+                case InputType.Json:
                     return new JsonFileHandler(fileSystem);
-                case InputTypeEnum.Arm:
+                case InputType.Arm:
                     return new ArmParametersFileHandler(fileSystem);
                 default:
                     throw new ArgumentException("Unsupported input format");
             }
         }
 
-        internal static List<string> GetExpectedFileExtensions(InputTypeEnum inputType)
+        internal static List<string> GetExpectedFileExtensions(InputType inputType)
         {
             switch (inputType)
             {
-                case InputTypeEnum.Json:
+                case InputType.Json:
                     return new List<string> { ".json" };
-                case InputTypeEnum.Yaml:
+                case InputType.Yaml:
                     return new List<string> { ".yml", ".yaml" };
-                case InputTypeEnum.Arm:
+                case InputType.Arm:
                     return new List<string> { ".json" };
                 default:
                     throw new ArgumentException("Unsupported input type");
diff --git a/src/Task/FileHandlers/JsonFileHandler.cs b/src/Task/FileHandlers/JsonFileHandler.cs
@@ -7,6 +7,8 @@ public class JsonFileHandler : IOutputWriter, IInputReader
     {
         readonly IFileSystem fileSystem;
 
+        private readonly JsonSerializerOptions jsonOptions = new JsonSerializerOptions { WriteIndented = true };
+
         internal JsonFileHandler(IFileSystem fileSystem)
         {
             this.fileSystem = fileSystem;
@@ -24,7 +26,6 @@ public ValueTask<JsonElement> ReadInput(string inputPath)
         /// <inheritdoc/>
         public void WriteOutput(JsonElement? mergedData, string outputPath)
         {
-            var jsonOptions = new JsonSerializerOptions { WriteIndented = true };
             var jsonContent = JsonSerializer.Serialize(mergedData, jsonOptions);
             fileSystem.WriteAllText(outputPath, jsonContent);
         }
diff --git a/src/Task/FileSystem/FileSystem.cs b/src/Task/FileSystem/FileSystem.cs
@@ -2,7 +2,7 @@
 
 namespace AggregateConfigBuildTask
 {
-    internal class FileSystem : IFileSystem
+    internal sealed class FileSystem : IFileSystem
     {
         /// <inheritdoc/>
         public string[] GetFiles(string path, string searchPattern)
diff --git a/src/Task/JsonHelper.cs b/src/Task/JsonHelper.cs
@@ -72,14 +72,15 @@ public static Dictionary<string, string> ParseAdditionalProperties(string[] prop
         {
             var additionalPropertiesDict = new Dictionary<string, string>();
             const string unicodeEscape = "\u001F";
+            char[] split = new[] { '=' };
 
             if (properties != null)
             {
                 foreach (var property in properties)
                 {
                     var sanitizedProperty = property.Replace(@"\=", unicodeEscape);
 
-                    var keyValue = sanitizedProperty.Split(new[] { '=' }, 2);
+                    var keyValue = sanitizedProperty.Split(split, 2);
 
                     if (keyValue.Length == 2)
                     {
@@ -104,10 +105,10 @@ public static async Task<JsonElement> ConvertObjectToJsonElement(object value)
 
             using (var memoryStream = new MemoryStream())
             {
-                await JsonSerializer.SerializeAsync(memoryStream, value);
+                await JsonSerializer.SerializeAsync(memoryStream, value).ConfigureAwait(false);
                 memoryStream.Seek(0, SeekOrigin.Begin);
 
-                using (var jsonDocument = await JsonDocument.ParseAsync(memoryStream))
+                using (var jsonDocument = await JsonDocument.ParseAsync(memoryStream).ConfigureAwait(false))
                 {
                     return jsonDocument.RootElement.Clone();
                 }
diff --git a/src/Task/ObjectManager.cs b/src/Task/ObjectManager.cs
diff --git a/src/UnitTests/TaskTestBase.cs b/src/UnitTests/TaskTestBase.cs
diff --git a/src/UnitTests/UnitTests.csproj b/src/UnitTests/UnitTests.csproj
diff --git a/src/UnitTests/VirtualFileSystem.cs b/src/UnitTests/VirtualFileSystem.cs

Original file line number	Diff line number	Diff line change
`@@ -1,20 +1,20 @@`
`1`	`1`	`namespace AggregateConfigBuildTask.Contracts`
`2`	`2`	`{`
`3`		`- public enum OutputTypeEnum`
	`3`	`+ public enum OutputType`
`4`	`4`	`{`
`5`		`- Json,`
`6`		`- Arm,`
	`5`	`+ Json = 0,`
	`6`	`+ Arm = 1,`
`7`	`7`	`ArmParameter = Arm,`
`8`		`- Yml,`
	`8`	`+ Yml = 2,`
`9`	`9`	`Yaml = Yml`
`10`	`10`	`}`
`11`	`11`
`12`		`- public enum InputTypeEnum`
	`12`	`+ public enum InputType`
`13`	`13`	`{`
`14`		`- Json,`
`15`		`- Arm,`
	`14`	`+ Json = 0,`
	`15`	`+ Arm = 1,`
`16`	`16`	`ArmParameter = Arm,`
`17`		`- Yml,`
	`17`	`+ Yml = 2,`
`18`	`18`	`Yaml = Yml`
`19`	`19`	`}`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public class AggregateConfig : Task`
`26`	`26`	`[Required]`
`27`	`27`	`public string OutputType { get; set; }`
`28`	`28`
`29`		`- public bool AddSourceProperty { get; set; } = false;`
	`29`	`+ public bool AddSourceProperty { get; set; }`
`30`	`30`
`31`	`31`	`public string[] AdditionalProperties { get; set; }`
`32`	`32`
`@@ -48,18 +48,18 @@ public override bool Execute()`
`48`	`48`
`49`	`49`	`OutputFile = Path.GetFullPath(OutputFile);`
`50`	`50`
`51`		`- if (!Enum.TryParse(OutputType, true, out OutputTypeEnum outputType) \|\|`
`52`		`- !Enum.IsDefined(typeof(OutputTypeEnum), outputType))`
	`51`	`+ if (!Enum.TryParse(OutputType, true, out OutputType outputType) \|\|`
	`52`	`+ !Enum.IsDefined(typeof(OutputType), outputType))`
`53`	`53`	`{`
`54`		`- Log.LogError("Invalid OutputType: {0}. Available options: {1}", OutputType, string.Join(", ", Enum.GetNames(typeof(OutputTypeEnum))));`
	`54`	`+ Log.LogError("Invalid OutputType: {0}. Available options: {1}", OutputType, string.Join(", ", Enum.GetNames(typeof(OutputType))));`
`55`	`55`	`return false;`
`56`	`56`	`}`
`57`	`57`
`58`		`- InputTypeEnum inputType = InputTypeEnum.Yaml;`
	`58`	`+ InputType inputType = Contracts.InputType.Yaml;`
`59`	`59`	`if (!string.IsNullOrEmpty(InputType) &&`
`60`		`- (!Enum.TryParse(InputType, true, out inputType) \|\| !Enum.IsDefined(typeof(InputTypeEnum), inputType)))`
	`60`	`+ (!Enum.TryParse(InputType, true, out inputType) \|\| !Enum.IsDefined(typeof(InputType), inputType)))`
`61`	`61`	`{`
`62`		`- Log.LogError("Invalid InputType: {0}. Available options: {1}", InputType, string.Join(", ", Enum.GetNames(typeof(InputTypeEnum))));`
	`62`	`+ Log.LogError("Invalid InputType: {0}. Available options: {1}", InputType, string.Join(", ", Enum.GetNames(typeof(InputType))));`
`63`	`63`	`return false;`
`64`	`64`	`}`
`65`	`65`
`@@ -103,7 +103,7 @@ private void EmitHeader()`
`103`	`103`	`.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?`
`104`	`104`	`.InformationalVersion;`
`105`	`105`
`106`		`- Log.LogMessage($"AggregateConfig Version: {informationalVersion}");`
	`106`	`+ Log.LogMessage(MessageImportance.High, $"AggregateConfig Version: {informationalVersion}");`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,19 +8,21 @@ namespace AggregateConfigBuildTask.FileHandlers`
`8`	`8`	`{`
`9`	`9`	`public class ArmParametersFileHandler : IOutputWriter, IInputReader`
`10`	`10`	`{`
`11`		`- readonly IFileSystem fileSystem;`
	`11`	`+ private readonly IFileSystem fileSystem;`
	`12`	`+`
	`13`	`+ private readonly JsonSerializerOptions jsonOptions = new JsonSerializerOptions { WriteIndented = true };`
`12`	`14`
`13`	`15`	`internal ArmParametersFileHandler(IFileSystem fileSystem)`
`14`	`16`	`{`
`15`	`17`	`this.fileSystem = fileSystem;`
`16`	`18`	`}`
`17`	`19`
`18`	`20`	`/// <inheritdoc/>`
`19`		`- public ValueTask<JsonElement> ReadInput(string inputPath)`
	`21`	`+ public async ValueTask<JsonElement> ReadInput(string inputPath)`
`20`	`22`	`{`
`21`	`23`	`using (var stream = fileSystem.OpenRead(inputPath))`
`22`	`24`	`{`
`23`		`- using (var jsonDoc = JsonDocument.Parse(stream))`
	`25`	`+ using (var jsonDoc = await JsonDocument.ParseAsync(stream).ConfigureAwait(false))`
`24`	`26`	`{`
`25`	`27`	`if (jsonDoc.RootElement.TryGetProperty("parameters", out JsonElement parameters))`
`26`	`28`	`{`
`@@ -41,10 +43,10 @@ public ValueTask<JsonElement> ReadInput(string inputPath)`
`41`	`43`	`}`
`42`	`44`
`43`	`45`	`var modifiedJson = modifiedParameters.ToJsonString();`
`44`		`- return new ValueTask<JsonElement>(Task.FromResult(JsonSerializer.Deserialize<JsonElement>(modifiedJson)));`
	`46`	`+ return JsonSerializer.Deserialize<JsonElement>(modifiedJson);`
`45`	`47`	`}`
`46`	`48`
`47`		`- return new ValueTask<JsonElement>(Task.FromResult(jsonDoc.RootElement.Clone()));`
	`49`	`+ return jsonDoc.RootElement.Clone();`
`48`	`50`	`}`
`49`	`51`	`}`
`50`	`52`	`}`
`@@ -74,8 +76,6 @@ public void WriteOutput(JsonElement? mergedData, string outputPath)`
`74`	`76`	`["contentVersion"] = "1.0.0.0",`
`75`	`77`	`["parameters"] = parameters`
`76`	`78`	`};`
`77`		`-`
`78`		`- var jsonOptions = new JsonSerializerOptions { WriteIndented = true };`
`79`	`79`	`var jsonContent = JsonSerializer.Serialize(armTemplate, jsonOptions);`
`80`	`80`	`fileSystem.WriteAllText(outputPath, jsonContent);`
`81`	`81`	`}`
`@@ -90,7 +90,7 @@ public void WriteOutput(JsonElement? mergedData, string outputPath)`
`90`	`90`	`/// </summary>`
`91`	`91`	`/// <param name="value">The JsonElement value to evaluate.</param>`
`92`	`92`	`/// <returns>A string representing the ARM template parameter type.</returns>`
`93`		`- private string GetParameterType(JsonElement value)`
	`93`	`+ private static string GetParameterType(JsonElement value)`
`94`	`94`	`{`
`95`	`95`	`switch (value.ValueKind)`
`96`	`96`	`{`
`@@ -115,7 +115,7 @@ private string GetParameterType(JsonElement value)`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`118`		`- private JsonNode ConvertElementToNode(JsonElement element)`
	`118`	`+ private static JsonNode ConvertElementToNode(JsonElement element)`
`119`	`119`	`{`
`120`	`120`	`// Use GetRawText to get the JSON string representation of the JsonElement`
`121`	`121`	`var jsonString = element.GetRawText();`
Original file line number	Diff line number	Diff line change
`@@ -6,45 +6,45 @@ namespace AggregateConfigBuildTask.FileHandlers`
`6`	`6`	`{`
`7`	`7`	`public static class FileHandlerFactory`
`8`	`8`	`{`
`9`		`- internal static IOutputWriter GetOutputWriter(IFileSystem fileSystem, OutputTypeEnum format)`
	`9`	`+ internal static IOutputWriter GetOutputWriter(IFileSystem fileSystem, OutputType format)`
`10`	`10`	`{`
`11`	`11`	`switch (format)`
`12`	`12`	`{`
`13`		`- case OutputTypeEnum.Json:`
	`13`	`+ case OutputType.Json:`
`14`	`14`	`return new JsonFileHandler(fileSystem);`
`15`		`- case OutputTypeEnum.Yaml:`
	`15`	`+ case OutputType.Yaml:`
`16`	`16`	`return new YamlFileHandler(fileSystem);`
`17`		`- case OutputTypeEnum.Arm:`
	`17`	`+ case OutputType.Arm:`
`18`	`18`	`return new ArmParametersFileHandler(fileSystem);`
`19`	`19`	`default:`
`20`	`20`	`throw new ArgumentException("Unsupported format");`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`24`		`- internal static IInputReader GetInputReader(IFileSystem fileSystem, InputTypeEnum format)`
	`24`	`+ internal static IInputReader GetInputReader(IFileSystem fileSystem, InputType format)`
`25`	`25`	`{`
`26`	`26`	`switch (format)`
`27`	`27`	`{`
`28`		`- case InputTypeEnum.Yaml:`
	`28`	`+ case InputType.Yaml:`
`29`	`29`	`return new YamlFileHandler(fileSystem);`
`30`		`- case InputTypeEnum.Json:`
	`30`	`+ case InputType.Json:`
`31`	`31`	`return new JsonFileHandler(fileSystem);`
`32`		`- case InputTypeEnum.Arm:`
	`32`	`+ case InputType.Arm:`
`33`	`33`	`return new ArmParametersFileHandler(fileSystem);`
`34`	`34`	`default:`
`35`	`35`	`throw new ArgumentException("Unsupported input format");`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
`39`		`- internal static List<string> GetExpectedFileExtensions(InputTypeEnum inputType)`
	`39`	`+ internal static List<string> GetExpectedFileExtensions(InputType inputType)`
`40`	`40`	`{`
`41`	`41`	`switch (inputType)`
`42`	`42`	`{`
`43`		`- case InputTypeEnum.Json:`
	`43`	`+ case InputType.Json:`
`44`	`44`	`return new List<string> { ".json" };`
`45`		`- case InputTypeEnum.Yaml:`
	`45`	`+ case InputType.Yaml:`
`46`	`46`	`return new List<string> { ".yml", ".yaml" };`
`47`		`- case InputTypeEnum.Arm:`
	`47`	`+ case InputType.Arm:`
`48`	`48`	`return new List<string> { ".json" };`
`49`	`49`	`default:`
`50`	`50`	`throw new ArgumentException("Unsupported input type");`