From 439e975c16316b18fe73a74b1f7d3c8e5654a1af Mon Sep 17 00:00:00 2001
From: StartAutomating <StartAutomating@github.com>
Date: Thu, 20 Jul 2023 07:58:42 +0000
Subject: [PATCH] Supporting Posh.Commands

Fixes #33, Fixes #42, Fixes #43, Fixes #44, Fixes #45, Fixes #46, Fixes #47, Fixes #48
---
 Posh.types.ps1xml | 521 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 521 insertions(+)

diff --git a/Posh.types.ps1xml b/Posh.types.ps1xml
index 7d75284..5a63622 100644
--- a/Posh.types.ps1xml
+++ b/Posh.types.ps1xml
@@ -1,6 +1,527 @@
 <?xml version="1.0" encoding="utf-16"?>
 <!-- Generated with EZOut 2.0: Install-Module EZOut or https://github.com/StartAutomating/EZOut -->
 <Types>
+  <Type>
+    <Name>Posh.Commands</Name>
+    <Members>
+      <MemberSet>
+        <Name>PSStandardMembers</Name>
+        <Members>
+          <PropertySet>
+            <Name>DefaultDisplayPropertySet</Name>
+            <ReferencedProperties>
+              <Name>Count</Name>
+              <Name>AliasCount</Name>
+              <Name>ApplicationCount</Name>
+              <Name>CmdletCount</Name>
+              <Name>FunctionCount</Name>
+            </ReferencedProperties>
+          </PropertySet>
+        </Members>
+      </MemberSet>
+      <AliasProperty>
+        <Name>Aliases</Name>
+        <ReferencedMemberName>Alias</ReferencedMemberName>
+      </AliasProperty>
+      <AliasProperty>
+        <Name>Applications</Name>
+        <ReferencedMemberName>Application</ReferencedMemberName>
+      </AliasProperty>
+      <AliasProperty>
+        <Name>Cmdlets</Name>
+        <ReferencedMemberName>Cmdlet</ReferencedMemberName>
+      </AliasProperty>
+      <AliasProperty>
+        <Name>Functions</Name>
+        <ReferencedMemberName>Function</ReferencedMemberName>
+      </AliasProperty>
+      <ScriptMethod>
+        <Name>FindExtensions</Name>
+        <Script>
+                        &lt;#
+.SYNOPSIS
+
+.DESCRIPTION
+
+.EXAMPLE
+    $posh.Commands.FindExtensions($posh, "$pwd")
+#&gt;
+$targetModules = @()
+$targetPaths = @()
+$loadedModules = Get-Module
+foreach ($arg in $args) {
+    if ($arg -is [Management.Automation.PSModuleInfo]) {
+        $targetModules += $arg
+    }
+    elseif ($arg -is [IO.FileInfo] -or $arg -is [IO.DirectoryInfo]) {
+        $targetPaths += $arg
+    } 
+    elseif ($arg -is [Management.Automation.PathInfo]) {
+        $targetPaths += "$arg"
+    }
+    elseif ($arg -is [string]) {
+        $argIsModule = 
+            foreach ($module in $loadedModules) { if ($module.Name -like $arg) { $module}}
+        if ($argIsModule) {
+            $targetModules += $argIsModule
+        } elseif (Test-Path $arg) {
+            $targetPaths += $arg
+        }
+        
+    }
+}
+
+if (-not $targetModules) { $targetModules = $posh.Modules}
+$Splat = @{}
+if ($targetPaths) {
+    $Splat.FilePath = $targetPaths
+}
+foreach ($module in $targetModules) {
+    # Aspect.ModuleExtendedCommand
+    &amp; { 
+        &lt;#
+        .SYNOPSIS
+            Returns a module's extended commands
+        .DESCRIPTION
+            Returns the commands or scripts in a module that match the module command pattern.
+            Each returned script will be decorated with the typename(s) that match,
+            so that the extended commands can be augmented by the extended types system.
+        .LINK
+            Aspect.ModuleCommandPattern
+        .EXAMPLE
+            Aspect.ModuleExtensionCommand -Module PipeScript # Should -BeOfType ([Management.Automation.CommandInfo])
+        #&gt;
+        [Alias('Aspect.ModuleExtendedCommand')]
+        param(
+        # The name of a module, or a module info object.
+        [Parameter(Mandatory,ValueFromPipelineByPropertyName)]
+        [ValidateScript({
+        $validTypeList = [System.String],[System.Management.Automation.PSModuleInfo]
+        $thisType = $_.GetType()
+        $IsTypeOk =
+            $(@( foreach ($validType in $validTypeList) {
+                if ($_ -as $validType) {
+                    $true;break
+                }
+            }))
+        if (-not $isTypeOk) {
+            throw "Unexpected type '$(@($thisType)[0])'.  Must be 'string','psmoduleinfo'."
+        }
+        return $true
+        })]
+        
+        $Module,
+        
+        # A list of commands.
+        # If this is provided, each command that is a valid extension will be returned.
+        [Parameter(ValueFromPipelineByPropertyName)]
+        [Management.Automation.CommandInfo[]]
+        $Commands,
+        # The suffix to apply to each named capture.
+        # Defaults to '_Command'
+        [Parameter(ValueFromPipelineByPropertyName)]
+        [string]
+        $Suffix = '_Command',
+        # The prefix to apply to each named capture. 
+        [Parameter(ValueFromPipelineByPropertyName)]
+        [string]
+        $Prefix,
+        # The file path(s).  If provided, will look for commands within these paths.
+        [Parameter(ValueFromPipelineByPropertyName)]
+        [Alias('Fullname')]    
+        $FilePath,
+        # The PowerShell command type.  If this is provided, will only get commands of this type.
+        [Parameter(ValueFromPipelineByPropertyName)]
+        [Management.Automation.CommandTypes]
+        $CommandType,
+        # The base PSTypeName(s).
+        # If provided, any commands that match the pattern will apply these typenames, too.
+        [string[]]
+        $PSTypeName
+        )
+        process {        
+            if ($Module -is [string]) {
+                $Module = Get-Module $Module
+            }
+            $ModuleInfo = $module
+            if (-not $ModuleInfo) { return }
+            
+            $ModuleCommandPattern = # Aspect.ModuleExtensionPattern
+                                    &amp; { 
+                                        &lt;#
+                                        .SYNOPSIS
+                                            Outputs a module's extension pattern
+                                        .DESCRIPTION
+                                            Outputs a regular expression that will match any possible pattern.
+                                        .EXAMPLE
+                                            Aspect.ModuleCommandPattern -Module PipeScript # Should -BeOfType ([Regex])
+                                        #&gt;
+                                        [Alias('Aspect.ModuleCommandPattern')]
+                                        param(
+                                        # The name of a module, or a module info object.
+                                        [Parameter(Mandatory,ValueFromPipelineByPropertyName)]
+                                        [ValidateScript({
+                                        $validTypeList = [System.String],[System.Management.Automation.PSModuleInfo]
+                                        $thisType = $_.GetType()
+                                        $IsTypeOk =
+                                            $(@( foreach ($validType in $validTypeList) {
+                                                if ($_ -as $validType) {
+                                                    $true;break
+                                                }
+                                            }))
+                                        if (-not $isTypeOk) {
+                                            throw "Unexpected type '$(@($thisType)[0])'.  Must be 'string','psmoduleinfo'."
+                                        }
+                                        return $true
+                                        })]
+                                        
+                                        $Module,
+                                        # The suffix to apply to each named capture.
+                                        # Defaults to '_Command'
+                                        [Parameter(ValueFromPipelineByPropertyName)]
+                                        [string]
+                                        $Suffix = '_Command',
+                                        # The prefix to apply to each named capture. 
+                                        [Parameter(ValueFromPipelineByPropertyName)]
+                                        [string]
+                                        $Prefix
+                                        )
+                                        process {
+                                            if ($Module -is [string]) {
+                                                $Module = Get-Module $Module
+                                            }
+                                            $ModuleInfo = $module
+                                            #region Search for Module Extension Types
+                                            if (-not $ModuleInfo) { return }
+                                            $ModuleExtensionTypes = # Aspect.ModuleExtensionTypes
+                                                                    &amp; { 
+                                                                        &lt;#
+                                                                        .SYNOPSIS
+                                                                            Outputs a module's extension types
+                                                                        .DESCRIPTION
+                                                                            Outputs the extension types defined in a module's manifest.
+                                                                        .EXAMPLE
+                                                                            # Outputs a PSObject with information about extension command types.
+                                                                            
+                                                                            # The two primary pieces of information are the `.Name` and `.Pattern`.
+                                                                            Aspect.ModuleExtensionType -Module PipeScript # Should -BeOfType ([PSObject])
+                                                                        #&gt;
+                                                                        [Alias('Aspect.ModuleCommandTypes','Aspect.ModuleCommandType','Aspect.ModuleExtensionTypes')]
+                                                                        param(
+                                                                        # The name of a module, or a module info object.
+                                                                        [Parameter(Mandatory,ValueFromPipelineByPropertyName)]
+                                                                        [ValidateScript({
+                                                                        $validTypeList = [System.String],[System.Management.Automation.PSModuleInfo]
+                                                                        $thisType = $_.GetType()
+                                                                        $IsTypeOk =
+                                                                            $(@( foreach ($validType in $validTypeList) {
+                                                                                if ($_ -as $validType) {
+                                                                                    $true;break
+                                                                                }
+                                                                            }))
+                                                                        if (-not $isTypeOk) {
+                                                                            throw "Unexpected type '$(@($thisType)[0])'.  Must be 'string','psmoduleinfo'."
+                                                                        }
+                                                                        return $true
+                                                                        })]
+                                                                        
+                                                                        $Module
+                                                                        )
+                                                                        begin {
+                                                                            $ExtensionCollectionNames = 
+                                                                                "Extension", "Command", "Cmdlet", "Function", "Alias", "Script", "Application", "File","Configuration"
+                                                                            $ExtensionCollectionNames = @($ExtensionCollectionNames -replace '.+$','${0}Type') + @($ExtensionCollectionNames -replace '.+$','${0}Types')
+                                                                        }
+                                                                        process {
+                                                                            #region Resolve Module Info
+                                                                            if ($Module -is [string]) {
+                                                                                $Module = Get-Module $Module
+                                                                            }
+                                                                            $ModuleInfo = $module                
+                                                                            if (-not $ModuleInfo) { return }
+                                                                            #endregion Resolve Module Info
+                                                                            #region Check Cache and Hopefully Return
+                                                                            if (-not $script:ModuleExtensionTypeCache) {
+                                                                                $script:ModuleExtensionTypeCache = @{}
+                                                                            }
+                                                                            
+                                                                            if ($script:ModuleExtensionTypeCache[$ModuleInfo]) {
+                                                                                return $script:ModuleExtensionTypeCache[$ModuleInfo]
+                                                                            }
+                                                                            #endregion Check Cache and Hopefully Return
+                                                                            #region Find Extension Types
+                                                                            $modulePrivateData  = $ModuleInfo.PrivateData
+                                                                            $SortedExtensionTypes = [Ordered]@{}
+                                                                            foreach ($TypeOfExtensionCollection in $ExtensionCollectionNames) {
+                                                                                $moduleExtensionTypes = 
+                                                                                    if ($modulePrivateData.$TypeOfExtensionCollection) {
+                                                                                        $modulePrivateData.$TypeOfExtensionCollection
+                                                                                    } elseif ($modulePrivateData.PSData.$TypeOfExtensionCollection) {
+                                                                                        $modulePrivateData.PSData.$TypeOfExtensionCollection
+                                                                                    } else {
+                                                                                        $null
+                                                                                    }
+                                                                                if (-not $moduleExtensionTypes) { continue } 
+                                                                                foreach ($commandType in @($ModuleExtensionTypes.GetEnumerator() | Sort-Object Key)) {
+                                                                                    if ($commandType.Value -is [Collections.IDictionary]) {
+                                                                                        if (-not $commandType.Value.Name) {
+                                                                                            $commandType.Value["Name"] = $commandType.Key
+                                                                                        }
+                                                                                        if (-not $commandType.Value.PSTypeName) {
+                                                                                            $commandType.Value["PSTypeName"] = "$($module.Name).ExtensionCommandType"
+                                                                                        }
+                                                                                        $SortedExtensionTypes[$commandType.Name] = $commandType.Value
+                                                                                    } else {
+                                                                                        $SortedExtensionTypes[$commandType.Name] = [Ordered]@{
+                                                                                            PSTypeName = "$($module.Name).ExtensionCommandType"
+                                                                                            Name    = $commandType.Key
+                                                                                            Pattern = $commandType.Value
+                                                                                        }
+                                                                                    }
+                                                                                    if ($TypeOfExtensionCollection -notmatch '(?&gt;Extension|Command|Cmdlet)') {
+                                                                                        $SortedExtensionTypes[$commandType.Name].CommandType = $TypeOfExtensionCollection -replace 'Type(?:s)?$'
+                                                                                    } elseif ($TypeOfExtensionCollection -match 'Cmdlet') {
+                                                                                        $SortedExtensionTypes[$commandType.Name].CommandType = "(?&gt;Alias|Function|Filter|Cmdlet)"
+                                                                                    }
+                                                                                }
+                                                                            }
+                                                                            
+                                                                            $SortedExtensionTypes.PSTypeName="$($Module.Name).ExtensionCommandTypes"
+                                                                            
+                                                                            $script:ModuleExtensionTypeCache[$ModuleInfo] = [PSCustomObject]$SortedExtensionTypes
+                                                                            $script:ModuleExtensionTypeCache[$ModuleInfo]
+                                                                            #endregion Find Extension Types
+                                                                        }    
+                                                                     } -Module $moduleInfo
+                                            
+                                            if (-not $ModuleExtensionTypes) { return }
+                                                
+                                            # With some clever understanding of Regular expressions, we can make match any/all of our potential command types.
+                                            # Essentially: Regular Expressions can look ahead (matching without changing the position), and be optional.
+                                            # So we can say "any/all" by making a series of optional lookaheads.
+                                            
+                                            # We'll go thru each pattern in order
+                                            $combinedRegex = @(foreach ($categoryExtensionTypeInfo in @($ModuleExtensionTypes.psobject.properties)) {
+                                                $categoryPattern = $categoryExtensionTypeInfo.Value.Pattern                
+                                                # ( and skip anyone that does not have a pattern)
+                                                if (-not $categoryPattern) { continue } 
+                                                '(?=' + # Start a lookahead
+                                                    '.{0,}' + # match any or no characters
+                                                    # followed by the command pattern
+                                                    "(?&lt;$Prefix$($categoryExtensionTypeInfo.Name -replace '\p{P}', '_')$Suffix&gt;$categoryPattern)" +
+                                                    ')?' # made optional                            
+                                            }) -join [Environment]::NewLine
+                                            # Now that we've combined the whole thing, make it a Regex and output it.        
+                                            [Regex]::new("$combinedRegex", 'IgnoreCase,IgnorePatternWhitespace','00:00:01')
+                                        }
+                                     } $ModuleInfo -Prefix $prefix -Suffix $Suffix
+            $ModuleCommandTypes   = # Aspect.ModuleExtensionType
+                                    &amp; { 
+                                        &lt;#
+                                        .SYNOPSIS
+                                            Outputs a module's extension types
+                                        .DESCRIPTION
+                                            Outputs the extension types defined in a module's manifest.
+                                        .EXAMPLE
+                                            # Outputs a PSObject with information about extension command types.
+                                            
+                                            # The two primary pieces of information are the `.Name` and `.Pattern`.
+                                            Aspect.ModuleExtensionType -Module PipeScript # Should -BeOfType ([PSObject])
+                                        #&gt;
+                                        [Alias('Aspect.ModuleCommandTypes','Aspect.ModuleCommandType','Aspect.ModuleExtensionTypes')]
+                                        param(
+                                        # The name of a module, or a module info object.
+                                        [Parameter(Mandatory,ValueFromPipelineByPropertyName)]
+                                        [ValidateScript({
+                                        $validTypeList = [System.String],[System.Management.Automation.PSModuleInfo]
+                                        $thisType = $_.GetType()
+                                        $IsTypeOk =
+                                            $(@( foreach ($validType in $validTypeList) {
+                                                if ($_ -as $validType) {
+                                                    $true;break
+                                                }
+                                            }))
+                                        if (-not $isTypeOk) {
+                                            throw "Unexpected type '$(@($thisType)[0])'.  Must be 'string','psmoduleinfo'."
+                                        }
+                                        return $true
+                                        })]
+                                        
+                                        $Module
+                                        )
+                                        begin {
+                                            $ExtensionCollectionNames = 
+                                                "Extension", "Command", "Cmdlet", "Function", "Alias", "Script", "Application", "File","Configuration"
+                                            $ExtensionCollectionNames = @($ExtensionCollectionNames -replace '.+$','${0}Type') + @($ExtensionCollectionNames -replace '.+$','${0}Types')
+                                        }
+                                        process {
+                                            #region Resolve Module Info
+                                            if ($Module -is [string]) {
+                                                $Module = Get-Module $Module
+                                            }
+                                            $ModuleInfo = $module                
+                                            if (-not $ModuleInfo) { return }
+                                            #endregion Resolve Module Info
+                                            #region Check Cache and Hopefully Return
+                                            if (-not $script:ModuleExtensionTypeCache) {
+                                                $script:ModuleExtensionTypeCache = @{}
+                                            }
+                                            
+                                            if ($script:ModuleExtensionTypeCache[$ModuleInfo]) {
+                                                return $script:ModuleExtensionTypeCache[$ModuleInfo]
+                                            }
+                                            #endregion Check Cache and Hopefully Return
+                                            #region Find Extension Types
+                                            $modulePrivateData  = $ModuleInfo.PrivateData
+                                            $SortedExtensionTypes = [Ordered]@{}
+                                            foreach ($TypeOfExtensionCollection in $ExtensionCollectionNames) {
+                                                $moduleExtensionTypes = 
+                                                    if ($modulePrivateData.$TypeOfExtensionCollection) {
+                                                        $modulePrivateData.$TypeOfExtensionCollection
+                                                    } elseif ($modulePrivateData.PSData.$TypeOfExtensionCollection) {
+                                                        $modulePrivateData.PSData.$TypeOfExtensionCollection
+                                                    } else {
+                                                        $null
+                                                    }
+                                                if (-not $moduleExtensionTypes) { continue } 
+                                                foreach ($commandType in @($ModuleExtensionTypes.GetEnumerator() | Sort-Object Key)) {
+                                                    if ($commandType.Value -is [Collections.IDictionary]) {
+                                                        if (-not $commandType.Value.Name) {
+                                                            $commandType.Value["Name"] = $commandType.Key
+                                                        }
+                                                        if (-not $commandType.Value.PSTypeName) {
+                                                            $commandType.Value["PSTypeName"] = "$($module.Name).ExtensionCommandType"
+                                                        }
+                                                        $SortedExtensionTypes[$commandType.Name] = $commandType.Value
+                                                    } else {
+                                                        $SortedExtensionTypes[$commandType.Name] = [Ordered]@{
+                                                            PSTypeName = "$($module.Name).ExtensionCommandType"
+                                                            Name    = $commandType.Key
+                                                            Pattern = $commandType.Value
+                                                        }
+                                                    }
+                                                    if ($TypeOfExtensionCollection -notmatch '(?&gt;Extension|Command|Cmdlet)') {
+                                                        $SortedExtensionTypes[$commandType.Name].CommandType = $TypeOfExtensionCollection -replace 'Type(?:s)?$'
+                                                    } elseif ($TypeOfExtensionCollection -match 'Cmdlet') {
+                                                        $SortedExtensionTypes[$commandType.Name].CommandType = "(?&gt;Alias|Function|Filter|Cmdlet)"
+                                                    }
+                                                }
+                                            }
+                                            
+                                            $SortedExtensionTypes.PSTypeName="$($Module.Name).ExtensionCommandTypes"
+                                            
+                                            $script:ModuleExtensionTypeCache[$ModuleInfo] = [PSCustomObject]$SortedExtensionTypes
+                                            $script:ModuleExtensionTypeCache[$ModuleInfo]
+                                            #endregion Find Extension Types
+                                        }    
+                                     } $ModuleInfo
+            
+            $commands    =
+                @(
+                if ($PSBoundParameters['Commands']) {
+                    $commands
+                }
+                elseif ($PSBoundParameters['FilePath']) {
+                    if (-not $commandType) {
+                        $commandType = 'Application,ExternalScript'
+                    }
+                    foreach ($file in Get-ChildItem -File -Path $PSBoundParameters['FilePath'] -Recurse) {
+                        $ExecutionContext.SessionState.InvokeCommand.GetCommand($file.FullName, $commandType)
+                    }
+                } else {
+                    if (-not $CommandType) {
+                        $commandType = 'Function,Alias,Filter,Cmdlet'
+                    }
+                    $ExecutionContext.SessionState.InvokeCommand.GetCommands('*', $commandType, $true)
+                })
+            :nextCommand foreach ($cmd in $commands) {            
+                $matched = $ModuleCommandPattern.Match("$cmd")
+                if (-not $matched.Success) { continue }
+                $NamedGroupMatch = $false
+                :nextCommandType foreach ($group in $matched.Groups) {
+                    if (-not $group.Success) { continue }
+                    if ($null -ne ($group.Name -as [int])) { continue }                
+                    $CommandTypeName     = $group.Name.Replace('_','.')
+                    $ThisCommandsType    = $ModuleCommandTypes.($group.Name -replace "^$prefix" -replace "$suffix$")
+                    if ($ThisCommandsType) {
+                        $ThisTypeFilter = @($ThisCommandsType.CommandType,$ThisCommandsType.CommandTypes -ne $null)[0]
+                        if ($ThisTypeFilter -and ($cmd.CommandType -notmatch $ThisTypeFilter)) {
+                            continue nextCommandType
+                        }
+                        $ThisExcludeFilter = @($ThisCommandsType.ExcludeCommandType,$ThisCommandsType.ExcludeCommandTypes -ne $null)[0]
+                        if ($ThisExcludeFilter -and ($cmd.CommandType -match $ThisExcludeFilter)) {
+                            continue nextCommandType
+                        }
+                    }
+                    $NamedGroupMatch     = $true
+                    if ($PSTypeName) {
+                        foreach ($psuedoType in $PSTypeName) {
+                            if ($cmd.pstypenames -notcontains $psuedoType) {
+                                $cmd.pstypenames.insert(0, $psuedoType)        
+                            }
+                        }
+                    }
+                    if ($cmd.pstypenames -notcontains $CommandTypeName) {
+                        $cmd.pstypenames.insert(0, $CommandTypeName)
+                    }
+                }
+                if ($NamedGroupMatch) {
+                    $cmd
+                }
+            }
+        }
+     } -Module $module @Splat
+}
+
+                    </Script>
+      </ScriptMethod>
+      <ScriptProperty>
+        <Name>AliasCount</Name>
+        <GetScriptBlock>
+                        @($this.Alias).Count
+                    </GetScriptBlock>
+      </ScriptProperty>
+      <ScriptProperty>
+        <Name>ApplicationCount</Name>
+        <GetScriptBlock>
+                        @($this.Application).Count
+                    </GetScriptBlock>
+      </ScriptProperty>
+      <ScriptProperty>
+        <Name>CmdletCount</Name>
+        <GetScriptBlock>
+                        @($this.Alias).Count
+                    </GetScriptBlock>
+      </ScriptProperty>
+      <ScriptProperty>
+        <Name>Count</Name>
+        <GetScriptBlock>
+                        @($this.All).Count
+                    </GetScriptBlock>
+      </ScriptProperty>
+      <ScriptProperty>
+        <Name>Extended</Name>
+        <GetScriptBlock>
+                        $this.FindExtensions()
+
+                    </GetScriptBlock>
+      </ScriptProperty>
+      <ScriptProperty>
+        <Name>FunctionCount</Name>
+        <GetScriptBlock>
+                        @($this.Function).Count
+                    </GetScriptBlock>
+      </ScriptProperty>
+      <NoteProperty>
+        <Name>DefaultDisplay</Name>
+        <Value>Count
+AliasCount
+ApplicationCount
+CmdletCount
+FunctionCount</Value>
+      </NoteProperty>
+    </Members>
+  </Type>
   <Type>
     <Name>Posh.Errors</Name>
     <Members>