Change from 'Parser' to 'Format'

'Parser' has one-way connotations.

Settle on 'Serialize' over 'Serialise' (as the rest of the project is in American English and mine and copilots mixed usage was getting confusing).

Stream -> string  in the Deserialize interface method as it wasn't helpful like I thought it might be

Author: liamjpeters

Engine/Settings/ISettingsFormat.cs

@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
+{
+    /// <summary>
+    /// Interface for settings file formats
+    /// </summary>
+    public interface ISettingsFormat
+    {
+        /// <summary>
+        /// Format identifier (extension without dot, e.g. 'json', 'psd1').
+        /// </summary>
+        string FormatName { get; }
+
+        /// <summary>
+        /// Whether this format can handle the specified path
+        /// </summary>
+        /// <param name="path">Full path or filename.</param>
+        /// <returns>True if this format can handle the path.</returns>
+        bool Supports(string path);
+
+        /// <summary>
+        /// Deserialises the content stream into <see cref="SettingsData"/>.
+        /// </summary>
+        /// <param name="content">The content to parse.</param>
+        /// <returns>The parsed SettingsData.</returns>
+        SettingsData Deserialize(string content, string sourcePath);
+
+        /// <summary>
+        /// Serializes the <see cref="SettingsData"/> into a string representation.
+        /// </summary>
+        /// <param name="settingsData"></param>
+        /// <returns></returns>
+        string Serialize(SettingsData settingsData);
+
+    }
+}

Engine/Settings/ISettingsParser.cs

@@ -11,7 +11,7 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
 {
 
     /// <summary>
-    /// Parses JSON settings files (extension .json) into <see cref="SettingsData"/>.
+    /// Handles JSON settings files (extension .json).
     /// Expected top-level properties:
     ///   Severity              : string or string array
     ///   IncludeRules          : string or string array
@@ -20,15 +20,8 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
     ///   IncludeDefaultRules   : bool
     ///   RecurseCustomRulePath : bool
     ///   Rules                 : object with ruleName -> { argumentName : value } mapping
-    /// Parsing logic:
-    /// 1. Read entire stream into a string.
-    /// 2. Deserialize to DTO with Newtonsoft.Json (case-insensitive by default).
-    /// 3. Validate null result -> invalid data.
-    /// 4. Normalize each collection to empty lists when absent.
-    /// 5. Rebuild rule arguments as case-insensitive dictionaries.
-    /// Throws <see cref="InvalidDataException"/> on malformed JSON or missing structure.
     /// </summary>
-    internal sealed class JsonSettingsParser : ISettingsParser
+    internal sealed class JsonSettingsFormat : ISettingsFormat
     {
 
         /// <summary>
@@ -48,12 +41,12 @@ private sealed class JsonSettingsDto
         public string FormatName => "json";
 
         /// <summary>
-        /// Determines if this parser can handle the supplied path by checking for .json extension.
+        /// Determines if this format can handle the supplied path by checking for .json extension.
         /// </summary>
-        /// <param name="pathOrExtension">File path or extension string.</param>
+        /// <param name="path">File path</param>
         /// <returns>True if extension is .json.</returns>
-        public bool CanParse(string pathOrExtension) =>
-            string.Equals(Path.GetExtension(pathOrExtension), ".json", StringComparison.OrdinalIgnoreCase);
+        public bool Supports(string path) =>
+            string.Equals(Path.GetExtension(path), ".json", StringComparison.OrdinalIgnoreCase);
 
         /// <summary>
         /// Parses a JSON settings file stream into <see cref="SettingsData"/>.
@@ -64,14 +57,12 @@ public bool CanParse(string pathOrExtension) =>
         /// <exception cref="InvalidDataException">
         /// Thrown on JSON deserialization error or invalid/empty root object.
         /// </exception>
-        public SettingsData Parse(Stream content, string sourcePath)
+        public SettingsData Deserialize(string content, string sourcePath)
         {
-            using var reader = new StreamReader(content);
-            string json = reader.ReadToEnd();
             JsonSettingsDto dto;
             try
             {
-                dto = JsonConvert.DeserializeObject<JsonSettingsDto>(json);
+                dto = JsonConvert.DeserializeObject<JsonSettingsDto>(content);
             }
             catch (JsonException je)
             {
@@ -112,7 +103,7 @@ public SettingsData Parse(Stream content, string sourcePath)
         /// <param name="pretty">True for indented JSON, false for minified.</param>
         /// <returns>JSON string suitable for saving as PSScriptAnalyzerSettings.json.</returns>
         /// <exception cref="ArgumentNullException">If <paramref name="data"/> is null.</exception>
-        public string Serialise(SettingsData data)
+        public string Serialize(SettingsData data)
         {
             if (data == null) throw new ArgumentNullException(nameof(data));
 

Engine/Settings/JsonSettingsParser.cs renamed to Engine/Settings/JsonSettingsFormat.cs

@@ -24,7 +24,7 @@ namespace Microsoft.Windows.PowerShell.ScriptAnalyzer
     /// Throws <see cref="InvalidDataException"/> for structural issues (missing hashtable, invalid
     /// values).
     /// </summary>
-    internal sealed class Psd1SettingsParser : ISettingsParser
+    internal sealed class Psd1SettingsFormat : ISettingsFormat
     {
         public string FormatName => "psd1";
 
@@ -33,30 +33,23 @@ internal sealed class Psd1SettingsParser : ISettingsParser
         /// </summary>
         /// <param name="pathOrExtension">Full path or just an extension string.</param>
         /// <returns>True if the extension is .psd1 (case-insensitive).</returns>
-        public bool CanParse(string pathOrExtension) =>
+        public bool Supports(string pathOrExtension) =>
             string.Equals(Path.GetExtension(pathOrExtension), ".psd1", StringComparison.OrdinalIgnoreCase);
 
         /// <summary>
-        /// Parses a .psd1 settings file into <see cref="SettingsData"/>.
+        /// Deserializes a .psd1 settings file into <see cref="SettingsData"/>.
         /// </summary>
         /// <param name="content">
-        /// Stream for API symmetry; not directly consumed (PowerShell parser reads from file path).
+        /// The content of the .psd1 file as a string.
         /// </param>
         /// <param name="sourcePath">Absolute or relative path to the .psd1 file.</param>
         /// <returns>Normalized <see cref="SettingsData"/> instance.</returns>
-        /// <exception cref="FileNotFoundException">If the file does not exist.</exception>
         /// <exception cref="InvalidDataException">
         /// If no top-level hashtable is found or conversion yields invalid data.
         /// </exception>
-        public SettingsData Parse(Stream content, string sourcePath)
+        public SettingsData Deserialize(string content, string sourcePath)
         {
-            // Need file path for PowerShell Parser.ParseFile
-            if (!File.Exists(sourcePath))
-            {
-                throw new FileNotFoundException("Settings file not found.", sourcePath);
-            }
-
-            Ast ast = Parser.ParseFile(sourcePath, out Token[] tokens, out ParseError[] errors);
+            Ast ast = Parser.ParseInput(content, out Token[] tokens, out ParseError[] errors);
 
             if (ast.FindAll(a => a is HashtableAst, false).FirstOrDefault() is not HashtableAst hashTableAst)
             {
@@ -87,7 +80,7 @@ public SettingsData Parse(Stream content, string sourcePath)
         /// </summary>
         /// <param name="settingsData">Settings to serialize.</param>
         /// <returns>Formatted .psd1 content as a string.</returns>
-        public string Serialise(SettingsData settingsData)
+        public string Serialize(SettingsData settingsData)
         {
             if (settingsData == null) throw new ArgumentNullException(nameof(settingsData));
 
@@ -124,24 +117,40 @@ string FormatScalar(object value)
                 };
             }
 
+            string FormatValue(object value)
+            {
+                // Non-string enumerable -> PowerShell array literal
+                if (value is System.Collections.IEnumerable en && value is not string)
+                {
+                    var items = new List<string>();
+                    foreach (var item in en)
+                    {
+                        // Treat nested enumerable of strings similarly; else fall back to scalar
+                        items.Add(FormatScalar(item));
+                    }
+                    return items.Count == 0
+                        ? "@()"
+                        : "@(" + string.Join(", ", items) + ")";
+                }
+                return FormatScalar(value);
+            }
+
             sb.AppendLine("@{");
 
-            // Ordered sections
             AppendStringList("IncludeRules", settingsData.IncludeRules);
             AppendStringList("ExcludeRules", settingsData.ExcludeRules);
             AppendStringList("Severity", settingsData.Severities);
             AppendStringList("CustomRulePath", settingsData.CustomRulePath);
 
             if (settingsData.IncludeDefaultRules)
             {
-                sb.Append(indent).Append("IncludeDefaultRules = ").AppendLine("$true").AppendLine();
+                sb.Append(indent).Append("IncludeDefaultRules = $true").AppendLine().AppendLine();
             }
             if (settingsData.RecurseCustomRulePath)
             {
-                sb.Append(indent).Append("RecurseCustomRulePath = ").AppendLine("$true").AppendLine();
+                sb.Append(indent).Append("RecurseCustomRulePath = $true").AppendLine().AppendLine();
             }
 
-            // Rules block
             if (settingsData.RuleArguments != null && settingsData.RuleArguments.Count > 0)
             {
                 sb.Append(indent).AppendLine("Rules = @{");
@@ -154,7 +163,7 @@ string FormatScalar(object value)
                         {
                             sb.Append(indent).Append(indent).Append(indent)
                               .Append(argKvp.Key).Append(" = ")
-                              .AppendLine(FormatScalar(argKvp.Value));
+                              .AppendLine(FormatValue(argKvp.Value));
                         }
                     }
                     sb.Append(indent).Append(indent).AppendLine("}").AppendLine();