Add compress support to PSAppDeployToolkit.CodeGen.PowerShellSyntaxSerializer.

Author: mjr4077au

src/PSADT/PSAppDeployToolkit/CodeGen/PowerShellSyntaxSerializer.cs

@@ -34,6 +34,21 @@ namespace PSAppDeployToolkit.CodeGen
     /// It is typically used to generate PowerShell code or scripts that recreate the serialized objects.</remarks>
     public static class PowerShellSyntaxSerializer
     {
+        /// <summary>
+        /// Serializes the specified object to a PowerShell-compatible string representation.
+        /// </summary>
+        /// <remarks>The returned string can be used in PowerShell scripts to recreate the original object
+        /// structure, where supported.</remarks>
+        /// <param name="value">The object to serialize. Can be null.</param>
+        /// <returns>A string containing the PowerShell syntax representation of the specified object. Returns an empty string if
+        /// the value is null.</returns>
+        public static string Serialize(object? value)
+        {
+            PowerShellSyntaxWriter writer = new();
+            WriteValue(value, writer);
+            return writer.ToString();
+        }
+
         /// <summary>
         /// Serializes the specified value to a PowerShell-formatted string.
         /// </summary>
@@ -47,6 +62,19 @@ public static string Serialize(object? value, string indentChars = "    ")
             return writer.ToString();
         }
 
+        /// <summary>
+        /// Serializes the specified object to a PowerShell syntax string, with optional compression.
+        /// </summary>
+        /// <param name="value">The object to serialize. Can be null.</param>
+        /// <param name="compress">true to compress the output; otherwise, false.</param>
+        /// <returns>A string containing the PowerShell syntax representation of the serialized object.</returns>
+        public static string Serialize(object? value, bool compress)
+        {
+            PowerShellSyntaxWriter writer = new(compress: compress);
+            WriteValue(value, writer);
+            return writer.ToString();
+        }
+
         /// <summary>
         /// Writes the specified value into the given <see cref="PowerShellSyntaxWriter"/>,
         /// checking registered converters first, then falling back to built-in handling.

src/PSADT/PSAppDeployToolkit/CodeGen/PowerShellSyntaxWriter.cs

@@ -19,6 +19,7 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.Management.Automation.Language;
 using System.Text;
 
@@ -32,7 +33,8 @@ namespace PSAppDeployToolkit.CodeGen
     /// such as for code generation or serialization scenarios. It manages indentation and escaping automatically to
     /// produce syntactically correct output.</remarks>
     /// <param name="indentChars">The string used for each indentation level. Defaults to four spaces. Cannot be null.</param>
-    internal sealed class PowerShellSyntaxWriter(string indentChars = "    ")
+    /// <param name="compress">When <see langword="true"/>, hashtables are emitted on a single line with semicolon separators.</param>
+    internal sealed class PowerShellSyntaxWriter(string indentChars = "    ", bool compress = false)
     {
         /// <summary>
         /// Writes the opening token of a PowerShell hashtable literal (<c>@{</c>)
@@ -46,6 +48,11 @@ public void WriteStartHashtable(bool ordered = false)
         {
             _ = _buffer.Append(ordered ? "[ordered]@{" : "@{");
             _depth++;
+            if (_compress)
+            {
+                _propertyWrittenStack.Push(_propertyWritten);
+                _propertyWritten = false;
+            }
         }
 
         /// <summary>
@@ -55,9 +62,17 @@ public void WriteStartHashtable(bool ordered = false)
         public void WriteEndHashtable()
         {
             _depth--;
-            _ = _buffer.AppendLine();
-            WriteIndent();
-            _ = _buffer.Append('}');
+            if (_compress)
+            {
+                _ = _buffer.Append(" }");
+                _propertyWritten = _propertyWrittenStack.Pop();
+            }
+            else
+            {
+                _ = _buffer.AppendLine();
+                WriteIndent();
+                _ = _buffer.Append('}');
+            }
         }
 
         /// <summary>
@@ -68,8 +83,16 @@ public void WriteEndHashtable()
         public void WritePropertyName(string name)
         {
             ArgumentNullException.ThrowIfNull(name);
-            _ = _buffer.AppendLine();
-            WriteIndent();
+            if (_compress)
+            {
+                _ = _buffer.Append(_propertyWritten ? "; " : " ");
+                _propertyWritten = true;
+            }
+            else
+            {
+                _ = _buffer.AppendLine();
+                WriteIndent();
+            }
             _ = _buffer.Append(name);
             _ = _buffer.Append(" = ");
         }
@@ -155,6 +178,8 @@ public void Reset()
         {
             _ = _buffer.Clear();
             _depth = 0;
+            _propertyWritten = false;
+            _propertyWrittenStack.Clear();
         }
 
         private void WriteIndent()
@@ -170,6 +195,21 @@ private void WriteIndent()
         /// </summary>
         private int _depth;
 
+        /// <summary>
+        /// Tracks whether a property has been written at the current hashtable depth (compressed mode).
+        /// </summary>
+        private bool _propertyWritten;
+
+        /// <summary>
+        /// When <see langword="true"/>, hashtables are emitted on a single line with semicolons.
+        /// </summary>
+        private readonly bool _compress = compress;
+
+        /// <summary>
+        /// Saves <see cref="_propertyWritten"/> state when entering nested hashtables.
+        /// </summary>
+        private readonly Stack<bool> _propertyWrittenStack = new();
+
         /// <summary>
         /// Stores the string used for indentation in formatted output.
         /// </summary>