Add compress support to PSAppDeployToolkit.CodeGen.PowerShellSyntaxSerializer.

Author: mjr4077au

src/PSADT/PSAppDeployToolkit/CodeGen/PowerShellSyntaxSerializer.cs

@@ -34,13 +34,41 @@ 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<T>(T value)
+        {
+            PowerShellSyntaxWriter writer = new();
+            WriteValue(value, writer);
+            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<T>(T value, bool compress)
+        {
+            PowerShellSyntaxWriter writer = new(compress);
+            WriteValue(value, writer);
+            return writer.ToString();
+        }
+
         /// <summary>
         /// Serializes the specified value to a PowerShell-formatted string.
         /// </summary>
         /// <param name="value">The object to serialize. Can be null.</param>
         /// <param name="indentChars">The string to use for indentation in the output. Defaults to four spaces.</param>
         /// <returns>A string containing the PowerShell-formatted representation of the value.</returns>
-        public static string Serialize<T>(T value, string indentChars = "    ")
+        public static string Serialize<T>(T value, string indentChars)
         {
             PowerShellSyntaxWriter writer = new(indentChars);
             WriteValue(value, writer);

src/PSADT/PSAppDeployToolkit/CodeGen/PowerShellSyntaxWriter.cs

@@ -19,6 +19,7 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.Management.Automation.Language;
 using System.Text;
 
@@ -31,9 +32,28 @@ namespace PSAppDeployToolkit.CodeGen
     /// <remarks>This class is designed to assist in emitting valid, human-readable PowerShell code fragments,
     /// 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 = "    ")
+    internal sealed class PowerShellSyntaxWriter()
     {
+        /// <summary>
+        /// Initializes a new instance of the PowerShellSyntaxWriter class with the specified compression option.
+        /// </summary>
+        /// <param name="compress">true to enable output compression; otherwise, false.</param>
+        internal PowerShellSyntaxWriter(bool compress) : this()
+        {
+            _compress = compress;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the PowerShellSyntaxWriter class with the specified indentation characters.
+        /// </summary>
+        /// <param name="indentChars">The string of characters to use for indentation in the generated PowerShell syntax. Cannot be null or
+        /// whitespace.</param>
+        internal PowerShellSyntaxWriter(string indentChars) : this()
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(indentChars);
+            _indentChars = indentChars;
+        }
+
         /// <summary>
         /// Writes the opening token of a PowerShell hashtable literal (<c>@{</c>)
         /// or ordered dictionary literal (<c>[ordered]@{</c>) and increases the
@@ -46,6 +66,11 @@ internal void WriteStartHashtable(bool ordered = false)
         {
             _ = _buffer.Append(ordered ? "[ordered]@{" : "@{");
             _depth++;
+            if (_compress)
+            {
+                _propertyWrittenStack.Push(_propertyWritten);
+                _propertyWritten = false;
+            }
         }
 
         /// <summary>
@@ -55,9 +80,17 @@ internal void WriteStartHashtable(bool ordered = false)
         internal void WriteEndHashtable()
         {
             _depth--;
-            _ = _buffer.AppendLine();
-            WriteIndent();
-            _ = _buffer.Append('}');
+            if (_compress)
+            {
+                _ = _buffer.Append(" }");
+                _propertyWritten = _propertyWrittenStack.Pop();
+            }
+            else
+            {
+                _ = _buffer.AppendLine();
+                WriteIndent();
+                _ = _buffer.Append('}');
+            }
         }
 
         /// <summary>
@@ -68,8 +101,16 @@ internal void WriteEndHashtable()
         internal 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(" = ");
         }
@@ -146,6 +187,8 @@ internal void Reset()
         {
             _ = _buffer.Clear();
             _depth = 0;
+            _propertyWritten = false;
+            _propertyWrittenStack.Clear();
         }
 
         /// <summary>
@@ -176,19 +219,34 @@ 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;
+
         /// <summary>
         /// Stores the string used for indentation in formatted output.
         /// </summary>
         /// <remarks>This field is initialized with the value provided to the constructor and cannot be
         /// null. It is typically used to control the appearance of indented text, such as in pretty-printing or
         /// structured formatting scenarios.</remarks>
-        private readonly string _indentChars = indentChars ?? throw new ArgumentNullException(nameof(indentChars));
+        private readonly string _indentChars = "    ";
 
         /// <summary>
         /// Represents the internal buffer used to accumulate or manipulate string data for this instance.
         /// </summary>
         /// <remarks>This field is intended for internal use and is not exposed to consumers of the class.
         /// Its contents may change as operations are performed.</remarks>
         private readonly StringBuilder _buffer = new();
+
+        /// <summary>
+        /// Saves <see cref="_propertyWritten"/> state when entering nested hashtables.
+        /// </summary>
+        private readonly Stack<bool> _propertyWrittenStack = new();
     }
 }