ConvertTo-Expression.ps1

<#PSScriptInfo
.VERSION 2.4.6
.GUID 5f167621-6abe-4153-a26c-f643e1716720
.AUTHOR Ronald Bode (iRon)
.DESCRIPTION Serializes an object to a PowerShell expression (PSON, PowerShell Object Notation).
.COMPANYNAME
.COPYRIGHT
.TAGS PSON PowerShell Object Notation expression serialize
.LICENSEURI https://github.com/iRon7/ConvertTo-Expression/LICENSE.txt
.PROJECTURI https://github.com/iRon7/ConvertTo-Expression
.ICONURI https://raw.githubusercontent.com/iRon7/ConvertTo-Expression/master/ConvertTo-Expression.png
.EXTERNALMODULEDEPENDENCIES
.REQUIREDSCRIPTS
.EXTERNALSCRIPTDEPENDENCIES
.RELEASENOTES
.PRIVATEDATA
#>


Function ConvertTo-Expression {
<#
    .SYNOPSIS
        Serializes an object to a PowerShell expression.
 
    .DESCRIPTION
        The ConvertTo-Expression cmdlet converts (serializes) an object to
        a PowerShell expression. The object can be stored in a variable,
        file or any other common storage for later use or to be ported to
        another system.
 
        Convert from expression
        An expression can be restored to an object by preceding it with an
        ampersand (&). An expression that is casted to a string can be
        restored to an object using the native Invoke-Expression cmdlet.
        An expression that is stored in a PowerShell (.ps1) file might also
        be directly invoked by the PowerShell dot-sourcing technique.
 
    .PARAMETER InputObject
        Specifies the objects to convert to a PowerShell expression. Enter
        a variable that contains the objects, or type a command or
        expression that gets the objects. You can also pipe one or more
        objects to ConvertTo-Expression.
 
    .PARAMETER Depth
        Specifies how many levels of contained objects are included in the
        PowerShell representation. The default value is 9.
 
    .PARAMETER Expand
        Specifies till what level the contained objects are expanded over
        separate lines and indented according to the -Indentation and
        -IndentChar parameters. The default value is 9.
         
        A negative value will remove redundant spaces and compress the
        PowerShell expression to a single line (except for multi-line
        strings).
         
        Xml documents and multi-line strings are embedded in a
        "here string" and aligned to the left.
         
    .PARAMETER Indentation
        Specifies how many IndentChars to write for each level in the
        hierarchy.
 
    .PARAMETER IndentChar
        Specifies which character to use for indenting.
 
    .PARAMETER TypePrefix
        Defines how the explicit the object type is being parsed:
 
        -TypePrefix None
            No type information will be added to the (embedded) objects and
            values in the PowerShell expression. This means that objects
            and values will be parsed to one of the following data types
            when reading them back with Invoke-Expression: a numeric value,
            a [String] ('...'), an [Array] (@(...)) or a [HashTable]
            (@{...}).
 
        -TypePrefix Native
            The original type prefix is added to the (embedded) objects and
            values in the PowerShell expression. Note that most system
            (.Net) objects can’t be read back with Invoke-Expression, but
            option might help to reveal (embedded) object types and
            hierarchies.
 
        -TypePrefix Cast (Default)
            The type prefix is only added to (embedded) objects and values
            when required and optimized for read back with
            Invoke-Expression by e.g. converting system (.Net) objects to
            PSCustomObject objects. Numeric values won't have a strict
            type and therefor parsed to the default type that fits the
            value when restored.
 
        -TypePrefix Strict
            All (embedded) objects and values will have an explicit type
            prefix optimized for read back with Invoke-Expression by e.g.
            converting system (.Net) objects to PSCustomObject objects.
 
    .PARAMETER NewLine
        Specifies which characters to use for a new line. The default is
        defined by the operating system.
 
    .PARAMETER Iteration
        Do not use (for internal use only).
 
    .EXAMPLE
 
        PS C:\> $Calendar = (Get-UICulture).Calendar | ConvertTo-Expression
         
        PS C:\> $Calendar
         
        [PSCustomObject]@{
                'AlgorithmType' = 'SolarCalendar'
                'CalendarType' = 'Localized'
                'Eras' = 1
                'IsReadOnly' = $False
                'MaxSupportedDateTime' = [DateTime]'9999-12-31T23:59:59.9999999'
                'MinSupportedDateTime' = [DateTime]'0001-01-01T00:00:00.0000000'
                'TwoDigitYearMax' = 2029
        }
         
        PS C:\> &$Calendar
 
        AlgorithmType : SolarCalendar
        CalendarType : Localized
        Eras : 1
        IsReadOnly : False
        MaxSupportedDateTime : 9999-12-31 11:59:59 PM
        MinSupportedDateTime : 0001-01-01 12:00:00 AM
        TwoDigitYearMax : 2029
 
    .EXAMPLE
 
        PS C:\>Get-Date | Select-Object -Property * | ConvertTo-Expression | Out-File .\Now.ps1
 
        PS C:\>$Now = .\Now.ps1 # $Now = Get-Content .\Now.Ps1 -Raw | Invoke-Expression
 
        PS C:\>$Now
 
        Date : 1963-10-07 12:00:00 AM
        DateTime : Monday, October 7, 1963 10:47:00 PM
        Day : 7
        DayOfWeek : Monday
        DayOfYear : 280
        DisplayHint : DateTime
        Hour : 22
        Kind : Local
        Millisecond : 0
        Minute : 22
        Month : 1
        Second : 0
        Ticks : 619388596200000000
        TimeOfDay : 22:47:00
        Year : 1963
 
    .EXAMPLE
 
        PS C:\>@{Account="User01";Domain="Domain01";Admin="True"} | ConvertTo-Expression -Expand -1 # Compress the PowerShell output
 
        @{'Admin'='True';'Account'='User01';'Domain'='Domain01'}
 
    .EXAMPLE
 
        PS C:\>WinInitProcess = Get-Process WinInit | ConvertTo-Expression # Convert the WinInit Process to a PowerShell expression
 
    .EXAMPLE
 
        PS C:\>Get-Host | ConvertTo-Expression -Depth 4 # Reveal complex object hierarchies
 
    .LINK
        Invoke-Expression (Alias ConvertFrom-Pson)
#>

    [CmdletBinding()][OutputType([ScriptBlock])]Param (
        [Parameter(ValueFromPipeLine = $True)][Object[]]$InputObject, [Int]$Depth = 9, [Int]$Expand = 9,
        [Int]$Indentation = 1, [String]$IndentChar = "`t", [ValidateSet("None", "Native", "Cast", "Strict")][String]$TypePrefix = "Cast",
        [String]$NewLine = [System.Environment]::NewLine, [Int]$Iteration = 0
    )
    $PipeLine = $Input | ForEach-Object {$_}; If ($PipeLine) {$InputObject = $PipeLine}
    Function Iterate ($Value) {ConvertTo-Expression @(,$Value) $Depth $Expand $Indentation $IndentChar $TypePrefix $NewLine ($Iteration + 1)}
    Function Embed ($List, $Dictionary) {If ($Iteration -ge $Depth) {If ($Null -ne $Dictionary) {Return "@{}"} Else {Return "@()"}}
        $Items = ForEach ($Key in $List) {If ($Null -ne $Dictionary) {"'$Key'$Space=$Space" + (Iterate @(,$Dictionary.$Key))} Else {Iterate @(,$Key)}}
        $Open, $Join, $Separator, $Close = If ($Null -ne $Dictionary) {"@{", ";$Space", "$LineUp$Tab", "}"} Else {"@(", ",$Space", ",$LineUp$Tab", ")"}
        $Open + (&{If (($Iteration -ge $Expand) -or (@($Items).Count -le 1)) {$Items -Join $Join} Else {"$LineUp$Tab$($Items -Join $Separator)$LineUp"}}) + $Close
    }
    $Object = If (@($InputObject).Count -eq 1) {@($InputObject)[0]} Else {$InputObject}
    $Expression = If ($Null -eq $Object) {"`$Null"} Else {
        $Space = If ($Iteration -gt $Expand) {""} Else {" "}; $Tab = $IndentChar * $Indentation; $LineUp = "$NewLine$($Tab * $Iteration)"
        $Type = $Object.GetType().Name; $Parse = $Type; $Cast = $Null; $Enumerator = $Object.GetEnumerator.OverloadDefinitions
        $Pson = If ($Object -is [Boolean]) {If ($Object) {'$True'} Else {'$False'}}
        ElseIf ($Object -is [Char]) {$Cast = $Type; "'$Object'"}
        ElseIf ($Object -is [String]) {If ($Object -Match "[`r`n]") {"@'$NewLine$Object$NewLine'@$NewLine"} Else {"'$($Object.Replace('''', ''''''))'"}}
        ElseIf ($Object -is [DateTime]) {$Cast = $Type; "'$($Object.ToString('o'))'"}
        ElseIf ($Object -is [TimeSpan] -or $Object -is [Version]) {$Cast = $Type; "'$Object'"}
        ElseIf ($Object -is [ScriptBlock]) {"{$Object}"}
        ElseIf ($Object -is [Enum]) {$Parse = "String"; "'$($Object)'"}
        ElseIf ($Object -is [Xml]) {$Cast = "Xml"; $SW = New-Object System.IO.StringWriter; $XW = New-Object System.Xml.XmlTextWriter $SW
            $XW.Formatting = If ($Level -gt $Expand) {"None"} Else {"Indented"}; $XW.Indentation = $Indentation; $XW.IndentChar = $IndentChar
            $Object.WriteContentTo($XW); If ($Level -gt $Expand) {"'$SW'"} Else {"@'$NewLine$SW$NewLine'@$NewLine"}}
        ElseIf ($Object.GetType().Name -eq "DictionaryEntry" -or $Type -like "KeyValuePair*") {$Parse = "Hashtable"; Embed $Object.Key @{$Object.Key = $Object.Value}}
        ElseIf ($Object.GetType().Name -eq "OrderedDictionary") {$Cast = "Ordered"; Embed $Object.Keys $Object}
        ElseIf ($Enumerator -match "[\W]IDictionaryEnumerator[\W]") {$Parse = "Hashtable"; Embed $Object.Keys $Object}
        ElseIf ($Enumerator -match "[\W]IEnumerator[\W]" -or $Object.GetType().Name -eq "DataTable") {$Parse = "Array"; Embed $Object}
        Else {$Property = $Object | Get-Member -Type Property; If (!$Property) {$Property = $Object | Get-Member -Type NoteProperty}
            $Names = ForEach ($Name in ($Property | Select-Object -Expand "Name")) {$Object.PSObject.Properties |
                Where-Object {$_.Name -eq $Name -and $_.IsGettable} | Select-Object -Expand "Name"}
            If ($Property) {$Cast = "PSCustomObject"; Embed $Names $Object} Else {$Object}
        }
        Switch ($TypePrefix) {
            'None'      {"$Pson"}
            'Native'    {"[$Type]$Pson"}
            'Cast'      {If ($Cast) {"[$Cast]$Pson"} Else {"$Pson"}}
            'Strict'    {If ($Cast) {"[$Cast]$Pson"} Else {"[$Parse]$Pson"}}
        }
    }
    If ($Iteration) {$Expression} Else {[ScriptBlock]::Create($Expression)}
} Set-Alias pson ConvertTo-Expression; Set-Alias ctex ConvertTo-Expression
Set-Alias ConvertTo-Pson ConvertTo-Expression -Description "Serializes an object to a PowerShell expression."
Set-Alias ConvertFrom-Pson  Invoke-Expression -Description "Parses a PowerShell expression to an object."