Show-PSRunObject: function to inspect objects

[mdgrs-mei]

Example function to inspect objects interactively. It shows what methods and properties the passed object has. You can go down/up the object hierarchy with key presses.

It is similar to Show-ObjectTree, but you focus on one layer at a time and it's more keyboard-centric.

Entry Icons

Icon	Meaning
🔸	Expandable object.
🔹	Value type. Not expandable.
{}	Method.

Key Bindings

Key	Action
Enter	Return selected value.
Shift+Enter	Go down the hierarchy if the object is expandable.
Ctrl+C	Copy selected value to Clipboard.
Ctrl+X	Copy path to Clipboard.
Tab	Mark entry in MultiSelection mode.
Backspace on empty query	Go up the hierarchy.
Ctrl+R	Restart the menu.
Ctrl+K	Open Action window.
Escape	Quit.

Usage

Import-Module 'PathTo/Show-PSRunObject.psm1'
Get-Process | Show-PSRunObject
Get-Process | Show-PSRunObject -MultiSelection

Code

#Requires -Modules PowerShellRun

# Show-PSRunObject.psm1

function Show-PSRunObject {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true, ValueFromPipeline = $true)]
        [Object]$InputObject,

        [Switch]$MultiSelection
    )

    begin {
        $inputIndex = 0
    }

    process {
        switch ($inputIndex) {
            0 {
                $initialObject = $InputObject
            }
            1 {
                $list = [System.Collections.Generic.List[Object]]::new()
                $list.Add($initialObject)
                $initialObject = $list
                $initialObject.Add($InputObject)
            }
            default {
                $initialObject.Add($InputObject)
            }
        }
        $inputIndex++
    }

    end {
        $option = Get-PSRunDefaultSelectorOption
        $option.KeyBinding.DefaultActionKeys = [PowerShellRun.ActionKey]::new('Enter', 'Quit')
        $option.KeyBinding.DefaultActionKeysMultiSelection = [PowerShellRun.ActionKey]::new('Enter', 'Return selected values')

        $initialNode = @{
            Name = '$InputObject'
            Object = $initialObject
            CollectionIndex = $null
            Context = $null
            Parent = $null
        }
        $node = $initialNode.Clone()

        while ($true) {
            $option.Prompt = '{0}> ' -f (GetNodePath $node)
            if (IsDictionary $node.Object) {
                $result = $node.Object.Keys | ForEach-Object {
                    $entry = CreateEntry -Name $_ -Object $node.Object[$_]
                    $entry
                } | Invoke-PSRunSelectorCustom -MultiSelection:$MultiSelection -Option $option -Context $node.Context
            } elseif (IsIndexableCollection $node.Object) {
                $collectionIndex = 0
                $result = $node.Object | ForEach-Object {
                    if ($_.Name) {
                        $name = "[$collectionIndex] $($_.Name)"
                    } else {
                        $name = "[$collectionIndex]"
                    }
                    $entry = CreateEntry -Name $name -Object $_ -CollectionIndex $collectionIndex
                    $entry
                    $collectionIndex++
                } | Invoke-PSRunSelectorCustom -MultiSelection:$MultiSelection -Option $option -Context $node.Context
            } else {
                $members = $node.Object | Get-Member
                $result = $members | ForEach-Object {
                    $memberName = $_.Name

                    $isGettable = $true
                    $memberValue = $null
                    try {
                        $memberValue = $node.Object.$memberName
                    } catch {
                        $isGettable = $false
                    }

                    $entry = CreateEntry -Name $memberName -Object $memberValue
                    $entry.Description = if ($isGettable) { "$($PSSTyle.Formatting.TableHeader)[$($_.MemberType)]$($PSSTyle.Reset) " + $entry.Description } else { 'write-only' }
                    $entry
                } | Invoke-PSRunSelectorCustom -MultiSelection:$MultiSelection -Option $option -Context $node.Context
            }

            if ([PowerShellRun.ExitStatus]::Type -eq [PowerShellRun.ExitType]::QuitWithBackspaceOnEmptyQuery) {
                $node = $node.Parent
                if ($null -eq $node.Parent) {
                    $option.QuitWithBackspaceOnEmptyQuery = $false
                }
                continue
            }
            if ([PowerShellRun.ExitStatus]::Type -eq [PowerShellRun.ExitType]::Restart) {
                $node = $initialNode.Clone()
                continue
            }

            if ($result.MarkedEntries) {
                $result.MarkedEntries.UserData.Object
                return
            }

            if (-not $result.FocusedEntry) {
                return
            }

            $focusedName = $result.FocusedEntry.Name
            $focusedObject = $result.FocusedEntry.UserData.Object
            $parentNode = $node
            $parentNode.Context = $result.Context

            $node = @{
                Name = $focusedName
                Object = $focusedObject
                CollectionIndex = $result.FocusedEntry.UserData.CollectionIndex
                Context = $null
                Parent = $parentNode
            }

            if ($result.KeyCombination -eq 'Enter') {
                $focusedObject
                return
            } elseif ($result.KeyCombination -eq 'Shift+Enter') {
                $option.QuitWithBackspaceOnEmptyQuery = $true
                continue
            } elseif ($result.KeyCombination -eq 'Ctrl+C') {
                $focusedObject | Set-Clipboard
                return
            } elseif ($result.KeyCombination -eq 'Ctrl+X') {
                GetNodePath $node | Set-Clipboard
                return
            }
        }
    }
}

function GetNodePath($node) {
    $path = ''
    $isCollectionElemPrev = $false
    while ($node) {
        $isCollectionElem = $null -ne $node.CollectionIndex
        $name = if ($isCollectionElem) { '[{0}]' -f $node.CollectionIndex } else { $node.Name }

        if (-not $path) {
            $path = $name
        } elseif ($isCollectionElemPrev) {
            $path = '{0}{1}' -f $name, $path
        } else {
            $path = '{0}.{1}' -f $name, $path
        }

        $isCollectionElemPrev = $isCollectionElem
        $node = $node.Parent
    }
    $path
}

function CreateEntry($Name, $Object, $CollectionIndex) {
    $leafActions = @(
        [PowerShellRun.ActionKey]::new('Enter', 'Return value')
        [PowerShellRun.ActionKey]::new('Ctrl+C', 'Copy value to Clipboard')
        [PowerShellRun.ActionKey]::new('Ctrl+X', 'Copy path to Clipboard')
    )
    $parentActions = @(
        [PowerShellRun.ActionKey]::new('Enter', 'Return value')
        [PowerShellRun.ActionKey]::new('Shift+Enter', 'Drill down')
        [PowerShellRun.ActionKey]::new('Ctrl+C', 'Copy value to Clipboard')
        [PowerShellRun.ActionKey]::new('Ctrl+X', 'Copy path to Clipboard')
    )
    $methodTypes = @(
        [System.Management.Automation.PSMethod]
        [System.Management.Automation.PSScriptMethod]
        [System.Management.Automation.PSCodeMethod]
    )

    $isMethod = $false
    foreach ($methodType in $methodTypes) {
        if ($Object -is $methodType) {
            $isMethod = $true
            break
        }
    }
    $hasChildren = HasChildren $Object

    $entry = [PowerShellRun.SelectorEntry]::new()
    $entry.UserData = @{
        Object = $Object
        CollectionIndex = $CollectionIndex
    }
    $entry.Icon = if ($isMethod) {
        '{}'
    } elseif ($hasChildren) {
        '🔸'
    } else {
        '🔹'
    }
    $entry.Name = $Name
    $entry.Description = GetObjectDescription $Object
    $entry.PreviewAsyncScript = {
        param($object)

        if ($null -eq $object) {
            return ''
        }
        "$($PSStyle.Formatting.TableHeader)Type:$($PSStyle.Reset)`n{0}$($PSStyle.Formatting.TableHeader)Value:$($PSStyle.Reset)`n{1}" -f ($object.getType() | Out-String), ($object | Out-String)
    }
    $entry.PreviewAsyncScriptArgumentList = $Object
    $entry.ActionKeys = if ($isMethod -or (-not $hasChildren)) { $leafActions } else { $parentActions }
    $entry
}

function GetObjectDescription($object) {
    if ($null -eq $object) {
        return '$null'
    }
    if (-not (IsIndexableCollection $object)) {
        return [String]$object
    }

    $count = 0
    $type = $null
    foreach ($i in $object) {
        if (($null -ne $type) -and ($type -ne $i.getType())) {
            # Not a single type collection.
            return [String]$object
        }
        $type = $i.getType()
        $count++
    }

    '{0}[{1}]' -f $type, $count
}

function HasChildren($object) {
    if ($null -eq $object) {
        return $false
    }
    if ($object -is [string]) {
        return $false
    }

    -not $object.getType().IsValueType
}

function IsIndexableCollection($object) {
    if (-not [System.Management.Automation.LanguagePrimitives]::IsObjectEnumerable($object)) {
        return $false
    }
    $object[0] -ne $object
}

function IsDictionary($object) {
    $object -is [Hashtable] -or $object -is [ordered]
}

Export-ModuleMember -Function Show-PSRunObject

[Hrxn]

Much better than Show-ObjectTree, in my humble opinion..