actions/runner-images-sangeeth
1
0
Fork 0
mirror of https://github.com/actions/runner-images-sangeeth.git synced 2025-12-13 13:26:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

rename nodes in software report (#6763)

Browse Source
This commit is contained in:
Maxim Lobanov
2022-12-14 10:24:47 +01:00
committed by GitHub
parent e63632f872
commit 2f83bbaa50
7 changed files with 201 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
helpers/software-report-base/SoftwareReport.Comparer.psm1
View File

@@ -39,7 +39,7 @@ class SoftwareReportComparer {
# Nodes are equal but not identical, so something was changed # Nodes are equal but not identical, so something was changed
if ($currentReportNode -is [TableNode]) { if ($currentReportNode -is [TableNode]) {
$this.CompareSimilarTableNodes($sameNodeInPreviousReport, $currentReportNode, $Headers) $this.CompareSimilarTableNodes($sameNodeInPreviousReport, $currentReportNode, $Headers)
} elseif ($currentReportNode -is [ToolVersionsNode]) { } elseif ($currentReportNode -is [ToolVersionsListNode]) {
$this.CompareSimilarToolVersionsListNodes($sameNodeInPreviousReport, $currentReportNode, $Headers) $this.CompareSimilarToolVersionsListNodes($sameNodeInPreviousReport, $currentReportNode, $Headers)
} else { } else {
$this.ChangedItems.Add([ReportDifferenceItem]::new($sameNodeInPreviousReport, $currentReportNode, $Headers)) $this.ChangedItems.Add([ReportDifferenceItem]::new($sameNodeInPreviousReport, $currentReportNode, $Headers))
@@ -79,7 +79,7 @@ class SoftwareReportComparer {
} }
} }
hidden [void] CompareSimilarToolVersionsListNodes([ToolVersionsNode] $PreviousReportNode, [ToolVersionsNode] $CurrentReportNode, [Array] $Headers) { hidden [void] CompareSimilarToolVersionsListNodes([ToolVersionsListNode] $PreviousReportNode, [ToolVersionsListNode] $CurrentReportNode, [Array] $Headers) {
$previousReportMajorVersions = $PreviousReportNode.Versions | ForEach-Object { $PreviousReportNode.ExtractMajorVersion($_) } $previousReportMajorVersions = $PreviousReportNode.Versions | ForEach-Object { $PreviousReportNode.ExtractMajorVersion($_) }
$currentReportMajorVersion = $CurrentReportNode.Versions | ForEach-Object { $CurrentReportNode.ExtractMajorVersion($_) } $currentReportMajorVersion = $CurrentReportNode.Versions | ForEach-Object { $CurrentReportNode.ExtractMajorVersion($_) }
@@ -89,15 +89,15 @@ class SoftwareReportComparer {
$changedCurrentVersions = $CurrentReportNode.Versions | Where-Object { ($CurrentReportNode.ExtractMajorVersion($_) -in $previousReportMajorVersions) -and ($_ -notin $PreviousReportNode.Versions) } $changedCurrentVersions = $CurrentReportNode.Versions | Where-Object { ($CurrentReportNode.ExtractMajorVersion($_) -in $previousReportMajorVersions) -and ($_ -notin $PreviousReportNode.Versions) }
if ($addedVersions.Count -gt 0) { if ($addedVersions.Count -gt 0) {
$this.AddedItems.Add([ReportDifferenceItem]::new($null, [ToolVersionsNode]::new($CurrentReportNode.ToolName, $addedVersions, $CurrentReportNode.MajorVersionRegex, $true), $Headers)) $this.AddedItems.Add([ReportDifferenceItem]::new($null, [ToolVersionsListNode]::new($CurrentReportNode.ToolName, $addedVersions, $CurrentReportNode.MajorVersionRegex, $true), $Headers))
} }
if ($deletedVersions.Count -gt 0) { if ($deletedVersions.Count -gt 0) {
$this.DeletedItems.Add([ReportDifferenceItem]::new([ToolVersionsNode]::new($PreviousReportNode.ToolName, $deletedVersions, $PreviousReportNode.MajorVersionRegex, $true), $null, $Headers)) $this.DeletedItems.Add([ReportDifferenceItem]::new([ToolVersionsListNode]::new($PreviousReportNode.ToolName, $deletedVersions, $PreviousReportNode.MajorVersionRegex, $true), $null, $Headers))
} }
$previousChangedNode = ($changedPreviousVersions.Count -gt 0) ? [ToolVersionsNode]::new($PreviousReportNode.ToolName, $changedPreviousVersions, $PreviousReportNode.MajorVersionRegex, $true) : $null $previousChangedNode = ($changedPreviousVersions.Count -gt 0) ? [ToolVersionsListNode]::new($PreviousReportNode.ToolName, $changedPreviousVersions, $PreviousReportNode.MajorVersionRegex, $true) : $null
$currentChangedNode = ($changedCurrentVersions.Count -gt 0) ? [ToolVersionsNode]::new($CurrentReportNode.ToolName, $changedCurrentVersions, $CurrentReportNode.MajorVersionRegex, $true) : $null $currentChangedNode = ($changedCurrentVersions.Count -gt 0) ? [ToolVersionsListNode]::new($CurrentReportNode.ToolName, $changedCurrentVersions, $CurrentReportNode.MajorVersionRegex, $true) : $null
if ($previousChangedNode -and $currentChangedNode) { if ($previousChangedNode -and $currentChangedNode) {
$this.ChangedItems.Add([ReportDifferenceItem]::new($previousChangedNode, $currentChangedNode, $Headers)) $this.ChangedItems.Add([ReportDifferenceItem]::new($previousChangedNode, $currentChangedNode, $Headers))
} }
@@ -111,7 +111,7 @@ class SoftwareReportComparer {
hidden [Boolean] FilterExcludedNodes([BaseNode] $Node) { hidden [Boolean] FilterExcludedNodes([BaseNode] $Node) {
# We shouldn't show "Image Version" diff because it is already shown in report header # We shouldn't show "Image Version" diff because it is already shown in report header
if (($Node -is [ToolNode]) -and ($Node.ToolName -eq "Image Version:")) { if (($Node -is [ToolVersionNode]) -and ($Node.ToolName -eq "Image Version:")) {
return $false return $false
} }
@@ -313,7 +313,7 @@ class SoftwareReportComparerReport {
} }
[String] GetImageVersion([SoftwareReport] $Report) { [String] GetImageVersion([SoftwareReport] $Report) {
$imageVersionNode = $Report.Root.Children ?? @() | Where-Object { ($_ -is [ToolNode]) -and ($_.ToolName -eq "Image Version:") } | Select-Object -First 1 $imageVersionNode = $Report.Root.Children ?? @() | Where-Object { ($_ -is [ToolVersionNode]) -and ($_.ToolName -eq "Image Version:") } | Select-Object -First 1
return $imageVersionNode.Version ?? "Unknown version" return $imageVersionNode.Version ?? "Unknown version"
} }
} }

36
helpers/software-report-base/SoftwareReport.Nodes.psm1
View File

@@ -10,10 +10,10 @@ class NodesFactory {
static [BaseNode] ParseNodeFromObject($jsonObj) { static [BaseNode] ParseNodeFromObject($jsonObj) {
if ($jsonObj.NodeType -eq [HeaderNode].Name) { if ($jsonObj.NodeType -eq [HeaderNode].Name) {
return [HeaderNode]::FromJsonObject($jsonObj) return [HeaderNode]::FromJsonObject($jsonObj)
} elseif ($jsonObj.NodeType -eq [ToolNode].Name) { } elseif ($jsonObj.NodeType -eq [ToolVersionNode].Name) {
return [ToolNode]::FromJsonObject($jsonObj) return [ToolVersionNode]::FromJsonObject($jsonObj)
} elseif ($jsonObj.NodeType -eq [ToolVersionsNode].Name) { } elseif ($jsonObj.NodeType -eq [ToolVersionsListNode].Name) {
return [ToolVersionsNode]::FromJsonObject($jsonObj) return [ToolVersionsListNode]::FromJsonObject($jsonObj)
} elseif ($jsonObj.NodeType -eq [TableNode].Name) { } elseif ($jsonObj.NodeType -eq [TableNode].Name) {
return [TableNode]::FromJsonObject($jsonObj) return [TableNode]::FromJsonObject($jsonObj)
} elseif ($jsonObj.NodeType -eq [NoteNode].Name) { } elseif ($jsonObj.NodeType -eq [NoteNode].Name) {
@@ -53,25 +53,25 @@ class HeaderNode: BaseNode {
} }
} }
[HeaderNode] AddHeaderNode([String] $Title) { [HeaderNode] AddHeader([String] $Title) {
$node = [HeaderNode]::new($Title) $node = [HeaderNode]::new($Title)
$this.AddNode($node) $this.AddNode($node)
return $node return $node
} }
[void] AddToolNode([String] $ToolName, [String] $Version) { [void] AddToolVersion([String] $ToolName, [String] $Version) {
$this.AddNode([ToolNode]::new($ToolName, $Version)) $this.AddNode([ToolVersionNode]::new($ToolName, $Version))
} }
[void] AddToolVersionsNode([String] $ToolName, [Array] $Version, [String] $MajorVersionRegex, [Boolean] $InlineList) { [void] AddToolVersionsList([String] $ToolName, [Array] $Version, [String] $MajorVersionRegex, [Boolean] $InlineList) {
$this.AddNode([ToolVersionsNode]::new($ToolName, $Version, $MajorVersionRegex, $InlineList)) $this.AddNode([ToolVersionsListNode]::new($ToolName, $Version, $MajorVersionRegex, $InlineList))
} }
[void] AddTableNode([Array] $Table) { [void] AddTable([Array] $Table) {
$this.AddNode([TableNode]::FromObjectsArray($Table)) $this.AddNode([TableNode]::FromObjectsArray($Table))
} }
[void] AddNoteNode([String] $Content) { [void] AddNote([String] $Content) {
$this.AddNode([NoteNode]::new($Content)) $this.AddNode([NoteNode]::new($Content))
} }
@@ -124,10 +124,10 @@ class HeaderNode: BaseNode {
} }
# Node type to describe the tool with single version: "Bash 5.1.16" # Node type to describe the tool with single version: "Bash 5.1.16"
class ToolNode: BaseToolNode { class ToolVersionNode: BaseToolNode {
[String] $Version [String] $Version
ToolNode([String] $ToolName, [String] $Version): base($ToolName) { ToolVersionNode([String] $ToolName, [String] $Version): base($ToolName) {
$this.Version = $Version $this.Version = $Version
} }
@@ -148,17 +148,17 @@ class ToolNode: BaseToolNode {
} }
static [BaseNode] FromJsonObject($jsonObj) { static [BaseNode] FromJsonObject($jsonObj) {
return [ToolNode]::new($jsonObj.ToolName, $jsonObj.Version) return [ToolVersionNode]::new($jsonObj.ToolName, $jsonObj.Version)
} }
} }
# Node type to describe the tool with multiple versions "Toolcache Node.js 14.17.6 16.2.0 18.2.3" # Node type to describe the tool with multiple versions "Toolcache Node.js 14.17.6 16.2.0 18.2.3"
class ToolVersionsNode: BaseToolNode { class ToolVersionsListNode: BaseToolNode {
[Array] $Versions [Array] $Versions
[Regex] $MajorVersionRegex [Regex] $MajorVersionRegex
[String] $ListType [String] $ListType
ToolVersionsNode([String] $ToolName, [Array] $Versions, [String] $MajorVersionRegex, [Boolean] $InlineList): base($ToolName) { ToolVersionsListNode([String] $ToolName, [Array] $Versions, [String] $MajorVersionRegex, [Boolean] $InlineList): base($ToolName) {
$this.Versions = $Versions $this.Versions = $Versions
$this.MajorVersionRegex = [Regex]::new($MajorVersionRegex) $this.MajorVersionRegex = [Regex]::new($MajorVersionRegex)
$this.ListType = $InlineList ? "Inline" : "List" $this.ListType = $InlineList ? "Inline" : "List"
@@ -203,8 +203,8 @@ class ToolVersionsNode: BaseToolNode {
} }
} }
static [ToolVersionsNode] FromJsonObject($jsonObj) { static [ToolVersionsListNode] FromJsonObject($jsonObj) {
return [ToolVersionsNode]::new($jsonObj.ToolName, $jsonObj.Versions, $jsonObj.MajorVersionRegex, $jsonObj.ListType -eq "Inline") return [ToolVersionsListNode]::new($jsonObj.ToolName, $jsonObj.Versions, $jsonObj.MajorVersionRegex, $jsonObj.ListType -eq "Inline")
} }
hidden [void] ValidateMajorVersionRegex() { hidden [void] ValidateMajorVersionRegex() {

20
images/macos/software-report/SoftwareReport.Browsers.psm1
View File

@@ -1,14 +1,14 @@
function Build-BrowserSection { function Build-BrowserSection {
return @( return @(
[ToolNode]::new("Safari", $(Get-SafariVersion)) [ToolVersionNode]::new("Safari", $(Get-SafariVersion))
[ToolNode]::new("SafariDriver", $(Get-SafariDriverVersion)) [ToolVersionNode]::new("SafariDriver", $(Get-SafariDriverVersion))
[ToolNode]::new("Google Chrome", $(Get-ChromeVersion)) [ToolVersionNode]::new("Google Chrome", $(Get-ChromeVersion))
[ToolNode]::new("ChromeDriver", $(Get-ChromeDriverVersion)) [ToolVersionNode]::new("ChromeDriver", $(Get-ChromeDriverVersion))
[ToolNode]::new("Microsoft Edge", $(Get-EdgeVersion)) [ToolVersionNode]::new("Microsoft Edge", $(Get-EdgeVersion))
[ToolNode]::new("Microsoft Edge WebDriver", $(Get-EdgeDriverVersion)) [ToolVersionNode]::new("Microsoft Edge WebDriver", $(Get-EdgeDriverVersion))
[ToolNode]::new("Mozilla Firefox", $(Get-FirefoxVersion)) [ToolVersionNode]::new("Mozilla Firefox", $(Get-FirefoxVersion))
[ToolNode]::new("geckodriver", $(Get-GeckodriverVersion)) [ToolVersionNode]::new("geckodriver", $(Get-GeckodriverVersion))
[ToolNode]::new("Selenium server", $(Get-SeleniumVersion)) [ToolVersionNode]::new("Selenium server", $(Get-SeleniumVersion))
) )
} }
@@ -84,7 +84,7 @@ function Build-BrowserWebdriversEnvironmentTable {
} }
} }
$node.AddTableNode($table) $node.AddTable($table)
return $node return $node
} }

16
images/macos/software-report/SoftwareReport.Common.psm1
View File

@@ -87,7 +87,7 @@ function Get-GccVersions {
$versionList | Foreach-Object { $versionList | Foreach-Object {
$nameVersion = Run-Command "gcc-${_} --version" | Select-Object -First 1 $nameVersion = Run-Command "gcc-${_} --version" | Select-Object -First 1
$version = ($nameVersion -replace "^gcc-${_}").Trim() -replace '\).*$', ')' $version = ($nameVersion -replace "^gcc-${_}").Trim() -replace '\).*$', ')'
return [ToolNode]::new("GCC ${_}", "$version - available by ``gcc-${_}`` alias") return [ToolVersionNode]::new("GCC ${_}", "$version - available by ``gcc-${_}`` alias")
} }
} }
@@ -96,7 +96,7 @@ function Get-FortranVersions {
$versionList | Foreach-Object { $versionList | Foreach-Object {
$nameVersion = Run-Command "gfortran-${_} --version" | Select-Object -First 1 $nameVersion = Run-Command "gfortran-${_} --version" | Select-Object -First 1
$version = ($nameVersion -replace "^GNU Fortran").Trim() -replace '\).*$', ')' $version = ($nameVersion -replace "^GNU Fortran").Trim() -replace '\).*$', ')'
return [ToolNode]::new("GNU Fortran ${_}", "$version - available by ``gfortran-${_}`` alias") return [ToolVersionNode]::new("GNU Fortran ${_}", "$version - available by ``gfortran-${_}`` alias")
} }
} }
@@ -111,8 +111,8 @@ function Get-ClangLLVMVersions {
$homebrewClangVersion = $clangVersionRegex.Match($homebrewClangOutput).Groups['version'].Value $homebrewClangVersion = $clangVersionRegex.Match($homebrewClangOutput).Groups['version'].Value
return @( return @(
[ToolNode]::new("Clang/LLVM", $defaultClangVersion) [ToolVersionNode]::new("Clang/LLVM", $defaultClangVersion)
[ToolNode]::new("Clang/LLVM (Homebrew)", "$homebrewClangVersion - available on ``$homebrewClangPath``") [ToolVersionNode]::new("Clang/LLVM (Homebrew)", "$homebrewClangVersion - available on ``$homebrewClangPath``")
) )
} }
@@ -168,9 +168,9 @@ function Build-OSInfoSection {
$kernelVersion = $parsedSystemInfo[1].Replace($fieldsToInclude[1],"").Trim() $kernelVersion = $parsedSystemInfo[1].Replace($fieldsToInclude[1],"").Trim()
$osInfoNode = [HeaderNode]::new("macOS $version") $osInfoNode = [HeaderNode]::new("macOS $version")
$osInfoNode.AddToolNode("OS Version:", $systemVersion) $osInfoNode.AddToolVersion("OS Version:", $systemVersion)
$osInfoNode.AddToolNode("Kernel Version:", $kernelVersion) $osInfoNode.AddToolVersion("Kernel Version:", $kernelVersion)
$osInfoNode.AddToolNode("Image Version:", $ImageName.Split('_')[1]) $osInfoNode.AddToolVersion("Image Version:", $ImageName.Split('_')[1])
return $osInfoNode return $osInfoNode
} }
@@ -598,7 +598,7 @@ function Build-PackageManagementEnvironmentTable {
} }
} }
$node.AddTableNode($table) $node.AddTable($table)
return $node return $node
} }

294
images/macos/software-report/SoftwareReport.Generator.ps1
View File

@@ -29,180 +29,180 @@ $osInfo = Build-OSInfoSection $ImageName
# Software report # Software report
$softwareReport = [SoftwareReport]::new($osInfo) $softwareReport = [SoftwareReport]::new($osInfo)
$installedSoftware = $softwareReport.Root.AddHeaderNode("Installed Software") $installedSoftware = $softwareReport.Root.AddHeader("Installed Software")
# Language and Runtime # Language and Runtime
$languageAndRuntime = $installedSoftware.AddHeaderNode("Language and Runtime") $languageAndRuntime = $installedSoftware.AddHeader("Language and Runtime")
$languageAndRuntime.AddToolVersionsNode(".NET Core SDK", $(Get-DotnetVersionList), '^\d+\.\d+\.\d', $true) $languageAndRuntime.AddToolVersionsList(".NET Core SDK", $(Get-DotnetVersionList), '^\d+\.\d+\.\d', $true)
$languageAndRuntime.AddToolNode("Bash", $(Get-BashVersion)) $languageAndRuntime.AddToolVersion("Bash", $(Get-BashVersion))
$languageAndRuntime.AddNodes($(Get-ClangLLVMVersions)) $languageAndRuntime.AddNodes($(Get-ClangLLVMVersions))
$languageAndRuntime.AddNodes($(Get-GccVersions)) $languageAndRuntime.AddNodes($(Get-GccVersions))
$languageAndRuntime.AddNodes($(Get-FortranVersions)) $languageAndRuntime.AddNodes($(Get-FortranVersions))
$languageAndRuntime.AddToolNode("Go", $(Get-GoVersion)) $languageAndRuntime.AddToolVersion("Go", $(Get-GoVersion))
$languageAndRuntime.AddToolNode("Julia", $(Get-JuliaVersion)) $languageAndRuntime.AddToolVersion("Julia", $(Get-JuliaVersion))
$languageAndRuntime.AddToolNode("Kotlin", $(Get-KotlinVersion)) $languageAndRuntime.AddToolVersion("Kotlin", $(Get-KotlinVersion))
$languageAndRuntime.AddToolNode("Mono", $(Get-MonoVersion)) $languageAndRuntime.AddToolVersion("Mono", $(Get-MonoVersion))
$languageAndRuntime.AddToolNode("MSBuild", $(Get-MSBuildVersion)) $languageAndRuntime.AddToolVersion("MSBuild", $(Get-MSBuildVersion))
$languageAndRuntime.AddToolNode("Node.js", $(Get-NodeVersion)) $languageAndRuntime.AddToolVersion("Node.js", $(Get-NodeVersion))
$languageAndRuntime.AddToolNode("NVM", $(Get-NVMVersion)) $languageAndRuntime.AddToolVersion("NVM", $(Get-NVMVersion))
$languageAndRuntime.AddToolVersionsNode("NVM - Cached node versions", $(Get-NVMNodeVersionList), '^\d+', $true) $languageAndRuntime.AddToolVersionsList("NVM - Cached node versions", $(Get-NVMNodeVersionList), '^\d+', $true)
$languageAndRuntime.AddToolNode("Perl", $(Get-PerlVersion)) $languageAndRuntime.AddToolVersion("Perl", $(Get-PerlVersion))
$languageAndRuntime.AddToolNode("PHP", $(Get-PHPVersion)) $languageAndRuntime.AddToolVersion("PHP", $(Get-PHPVersion))
$languageAndRuntime.AddToolNode("Python", $(Get-PythonVersion)) $languageAndRuntime.AddToolVersion("Python", $(Get-PythonVersion))
$languageAndRuntime.AddToolNode("Python3", $(Get-Python3Version)) $languageAndRuntime.AddToolVersion("Python3", $(Get-Python3Version))
$languageAndRuntime.AddToolNode("R", $(Get-RVersion)) $languageAndRuntime.AddToolVersion("R", $(Get-RVersion))
$languageAndRuntime.AddToolNode("Ruby", $(Get-RubyVersion)) $languageAndRuntime.AddToolVersion("Ruby", $(Get-RubyVersion))
# Package Management # Package Management
$packageManagement = $installedSoftware.AddHeaderNode("Package Management") $packageManagement = $installedSoftware.AddHeader("Package Management")
$packageManagement.AddToolNode("Bundler", $(Get-BundlerVersion)) $packageManagement.AddToolVersion("Bundler", $(Get-BundlerVersion))
$packageManagement.AddToolNode("Carthage", $(Get-CarthageVersion)) $packageManagement.AddToolVersion("Carthage", $(Get-CarthageVersion))
$packageManagement.AddToolNode("CocoaPods", $(Get-CocoaPodsVersion)) $packageManagement.AddToolVersion("CocoaPods", $(Get-CocoaPodsVersion))
$packageManagement.AddToolNode("Composer", $(Get-ComposerVersion)) $packageManagement.AddToolVersion("Composer", $(Get-ComposerVersion))
$packageManagement.AddToolNode("Homebrew", $(Get-HomebrewVersion)) $packageManagement.AddToolVersion("Homebrew", $(Get-HomebrewVersion))
$packageManagement.AddToolNode("Miniconda", $(Get-CondaVersion)) $packageManagement.AddToolVersion("Miniconda", $(Get-CondaVersion))
$packageManagement.AddToolNode("NPM", $(Get-NPMVersion)) $packageManagement.AddToolVersion("NPM", $(Get-NPMVersion))
$packageManagement.AddToolNode("NuGet", $(Get-NuGetVersion)) $packageManagement.AddToolVersion("NuGet", $(Get-NuGetVersion))
$packageManagement.AddToolNode("Pip", $(Get-PipVersion -Version 2)) $packageManagement.AddToolVersion("Pip", $(Get-PipVersion -Version 2))
$packageManagement.AddToolNode("Pip3", $(Get-PipVersion -Version 3)) $packageManagement.AddToolVersion("Pip3", $(Get-PipVersion -Version 3))
$packageManagement.AddToolNode("Pipx", $(Get-PipxVersion)) $packageManagement.AddToolVersion("Pipx", $(Get-PipxVersion))
$packageManagement.AddToolNode("RubyGems", $(Get-RubyGemsVersion)) $packageManagement.AddToolVersion("RubyGems", $(Get-RubyGemsVersion))
$packageManagement.AddToolNode("Vcpkg", $(Get-VcpkgVersion)) $packageManagement.AddToolVersion("Vcpkg", $(Get-VcpkgVersion))
$packageManagement.AddToolNode("Yarn", $(Get-YarnVersion)) $packageManagement.AddToolVersion("Yarn", $(Get-YarnVersion))
$packageManagement.AddNode($(Build-PackageManagementEnvironmentTable)) $packageManagement.AddNode($(Build-PackageManagementEnvironmentTable))
# Project Management # Project Management
$projectanagement = $installedSoftware.AddHeaderNode("Project Management") $projectanagement = $installedSoftware.AddHeader("Project Management")
$projectanagement.AddToolNode("Apache Ant", $(Get-ApacheAntVersion)) $projectanagement.AddToolVersion("Apache Ant", $(Get-ApacheAntVersion))
$projectanagement.AddToolNode("Apache Maven", $(Get-MavenVersion)) $projectanagement.AddToolVersion("Apache Maven", $(Get-MavenVersion))
$projectanagement.AddToolNode("Gradle", $(Get-GradleVersion)) $projectanagement.AddToolVersion("Gradle", $(Get-GradleVersion))
$projectanagement.AddToolNode("Sbt", $(Get-SbtVersion)) $projectanagement.AddToolVersion("Sbt", $(Get-SbtVersion))
# Utilities # Utilities
$utilities = $installedSoftware.AddHeaderNode("Utilities") $utilities = $installedSoftware.AddHeader("Utilities")
$utilities.AddToolNode("7-Zip", $(Get-7zipVersion)) $utilities.AddToolVersion("7-Zip", $(Get-7zipVersion))
$utilities.AddToolNode("aria2", $(Get-Aria2Version)) $utilities.AddToolVersion("aria2", $(Get-Aria2Version))
$utilities.AddToolNode("azcopy", $(Get-AzcopyVersion)) $utilities.AddToolVersion("azcopy", $(Get-AzcopyVersion))
$utilities.AddToolNode("bazel", $(Get-BazelVersion)) $utilities.AddToolVersion("bazel", $(Get-BazelVersion))
$utilities.AddToolNode("bazelisk", $(Get-BazeliskVersion)) $utilities.AddToolVersion("bazelisk", $(Get-BazeliskVersion))
$utilities.AddToolNode("bsdtar", $(Get-BsdtarVersion)) $utilities.AddToolVersion("bsdtar", $(Get-BsdtarVersion))
$utilities.AddToolNode("Curl", $(Get-CurlVersion)) $utilities.AddToolVersion("Curl", $(Get-CurlVersion))
$utilities.AddToolNode("Git", $(Get-GitVersion)) $utilities.AddToolVersion("Git", $(Get-GitVersion))
$utilities.AddToolNode("Git LFS", $(Get-GitLFSVersion)) $utilities.AddToolVersion("Git LFS", $(Get-GitLFSVersion))
$utilities.AddToolNode("GitHub CLI", $(Get-GitHubCLIVersion)) $utilities.AddToolVersion("GitHub CLI", $(Get-GitHubCLIVersion))
if ($os.IsCatalina) { if ($os.IsCatalina) {
$utilities.AddToolNode("GNU parallel", $(Get-ParallelVersion)) $utilities.AddToolVersion("GNU parallel", $(Get-ParallelVersion))
} }
$utilities.AddToolNode("GNU Tar", $(Get-GnuTarVersion)) $utilities.AddToolVersion("GNU Tar", $(Get-GnuTarVersion))
$utilities.AddToolNode("GNU Wget", $(Get-WgetVersion)) $utilities.AddToolVersion("GNU Wget", $(Get-WgetVersion))
$utilities.AddToolNode("gpg (GnuPG)", $(Get-GPGVersion)) $utilities.AddToolVersion("gpg (GnuPG)", $(Get-GPGVersion))
if ($os.IsLessThanMonterey) { if ($os.IsLessThanMonterey) {
$utilities.AddToolNode("helm", $(Get-HelmVersion)) $utilities.AddToolVersion("helm", $(Get-HelmVersion))
} }
$utilities.AddToolNode("Hub CLI", $(Get-HubVersion)) $utilities.AddToolVersion("Hub CLI", $(Get-HubVersion))
$utilities.AddToolNode("ImageMagick", $(Get-ImageMagickVersion)) $utilities.AddToolVersion("ImageMagick", $(Get-ImageMagickVersion))
$utilities.AddToolNode("jq", $(Get-JqVersion)) $utilities.AddToolVersion("jq", $(Get-JqVersion))
$utilities.AddToolNode("mongo", $(Get-MongoVersion)) $utilities.AddToolVersion("mongo", $(Get-MongoVersion))
$utilities.AddToolNode("mongod", $(Get-MongodVersion)) $utilities.AddToolVersion("mongod", $(Get-MongodVersion))
if ($os.IsLessThanMonterey) { if ($os.IsLessThanMonterey) {
$utilities.AddToolNode("Newman", $(Get-NewmanVersion)) $utilities.AddToolVersion("Newman", $(Get-NewmanVersion))
} }
$utilities.AddToolNode("OpenSSL", $(Get-OpenSSLVersion)) $utilities.AddToolVersion("OpenSSL", $(Get-OpenSSLVersion))
$utilities.AddToolNode("Packer", $(Get-PackerVersion)) $utilities.AddToolVersion("Packer", $(Get-PackerVersion))
$utilities.AddToolNode("PostgreSQL", $(Get-PostgresServerVersion)) $utilities.AddToolVersion("PostgreSQL", $(Get-PostgresServerVersion))
$utilities.AddToolNode("psql (PostgreSQL)", $(Get-PostgresClientVersion)) $utilities.AddToolVersion("psql (PostgreSQL)", $(Get-PostgresClientVersion))
$utilities.AddToolNode("Sox", $(Get-SoxVersion)) $utilities.AddToolVersion("Sox", $(Get-SoxVersion))
$utilities.AddToolNode("Subversion (SVN)", $(Get-SVNVersion)) $utilities.AddToolVersion("Subversion (SVN)", $(Get-SVNVersion))
$utilities.AddToolNode("Switchaudio-osx", $(Get-SwitchAudioOsxVersion)) $utilities.AddToolVersion("Switchaudio-osx", $(Get-SwitchAudioOsxVersion))
if (-not $os.IsBigSur) { if (-not $os.IsBigSur) {
$utilities.AddToolNode("Vagrant", $(Get-VagrantVersion)) $utilities.AddToolVersion("Vagrant", $(Get-VagrantVersion))
$utilities.AddToolNode("VirtualBox", $(Get-VirtualBoxVersion)) $utilities.AddToolVersion("VirtualBox", $(Get-VirtualBoxVersion))
} }
$utilities.AddToolNode("yq", $(Get-YqVersion)) $utilities.AddToolVersion("yq", $(Get-YqVersion))
$utilities.AddToolNode("zstd", $(Get-ZstdVersion)) $utilities.AddToolVersion("zstd", $(Get-ZstdVersion))
# Tools # Tools
$tools = $installedSoftware.AddHeaderNode("Tools") $tools = $installedSoftware.AddHeader("Tools")
if ($os.IsLessThanMonterey) { if ($os.IsLessThanMonterey) {
$tools.AddToolNode("Aliyun CLI", $(Get-AliyunCLIVersion)) $tools.AddToolVersion("Aliyun CLI", $(Get-AliyunCLIVersion))
} }
$tools.AddToolNode("App Center CLI", $(Get-AppCenterCLIVersion)) $tools.AddToolVersion("App Center CLI", $(Get-AppCenterCLIVersion))
$tools.AddToolNode("AWS CLI", $(Get-AWSCLIVersion)) $tools.AddToolVersion("AWS CLI", $(Get-AWSCLIVersion))
$tools.AddToolNode("AWS SAM CLI", $(Get-AWSSAMCLIVersion)) $tools.AddToolVersion("AWS SAM CLI", $(Get-AWSSAMCLIVersion))
$tools.AddToolNode("AWS Session Manager CLI", $(Get-AWSSessionManagerCLIVersion)) $tools.AddToolVersion("AWS Session Manager CLI", $(Get-AWSSessionManagerCLIVersion))
$tools.AddToolNode("Azure CLI", $(Get-AzureCLIVersion)) $tools.AddToolVersion("Azure CLI", $(Get-AzureCLIVersion))
$tools.AddToolNode("Azure CLI (azure-devops)", $(Get-AzureDevopsVersion)) $tools.AddToolVersion("Azure CLI (azure-devops)", $(Get-AzureDevopsVersion))
$tools.AddToolNode("Bicep CLI", $(Get-BicepVersion)) $tools.AddToolVersion("Bicep CLI", $(Get-BicepVersion))
$tools.AddToolNode("Cabal", $(Get-CabalVersion)) $tools.AddToolVersion("Cabal", $(Get-CabalVersion))
$tools.AddToolNode("Cmake", $(Get-CmakeVersion)) $tools.AddToolVersion("Cmake", $(Get-CmakeVersion))
if (-not $os.IsCatalina) { if (-not $os.IsCatalina) {
$tools.AddToolNode("CodeQL Action Bundle", $(Get-CodeQLBundleVersion)) $tools.AddToolVersion("CodeQL Action Bundle", $(Get-CodeQLBundleVersion))
} }
if (-not $os.IsCatalina) { if (-not $os.IsCatalina) {
$tools.AddToolNode("Colima", $(Get-ColimaVersion)) $tools.AddToolVersion("Colima", $(Get-ColimaVersion))
} }
$tools.AddToolNode("Fastlane", $(Get-FastlaneVersion)) $tools.AddToolVersion("Fastlane", $(Get-FastlaneVersion))
$tools.AddToolNode("GHC", $(Get-GHCVersion)) $tools.AddToolVersion("GHC", $(Get-GHCVersion))
$tools.AddToolNode("GHCup", $(Get-GHCupVersion)) $tools.AddToolVersion("GHCup", $(Get-GHCupVersion))
$tools.AddToolNode("Jazzy", $(Get-JazzyVersion)) $tools.AddToolVersion("Jazzy", $(Get-JazzyVersion))
$tools.AddToolNode("Stack", $(Get-StackVersion)) $tools.AddToolVersion("Stack", $(Get-StackVersion))
$tools.AddToolNode("SwiftFormat", $(Get-SwiftFormatVersion)) $tools.AddToolVersion("SwiftFormat", $(Get-SwiftFormatVersion))
$tools.AddToolNode("Swig", $(Get-SwigVersion)) $tools.AddToolVersion("Swig", $(Get-SwigVersion))
$tools.AddToolNode("Xcode Command Line Tools", $(Get-XcodeCommandLineToolsVersion)) $tools.AddToolVersion("Xcode Command Line Tools", $(Get-XcodeCommandLineToolsVersion))
# Linters # Linters
$linters = $installedSoftware.AddHeaderNode("Linters") $linters = $installedSoftware.AddHeader("Linters")
$linters.AddToolNode("SwiftLint", $(Get-SwiftLintVersion)) $linters.AddToolVersion("SwiftLint", $(Get-SwiftLintVersion))
$linters.AddToolNode("Yamllint", $(Get-YamllintVersion)) $linters.AddToolVersion("Yamllint", $(Get-YamllintVersion))
# Browsers # Browsers
$browsers = $installedSoftware.AddHeaderNode("Browsers") $browsers = $installedSoftware.AddHeader("Browsers")
$browsers.AddNodes($(Build-BrowserSection)) $browsers.AddNodes($(Build-BrowserSection))
$browsers.AddNode($(Build-BrowserWebdriversEnvironmentTable)) $browsers.AddNode($(Build-BrowserWebdriversEnvironmentTable))
# Java # Java
$java = $installedSoftware.AddHeaderNode("Java") $java = $installedSoftware.AddHeader("Java")
$java.AddTableNode($(Get-JavaVersions)) $java.AddTable($(Get-JavaVersions))
# Graal # Graal
$graalvm = $installedSoftware.AddHeaderNode("GraalVM") $graalvm = $installedSoftware.AddHeader("GraalVM")
$graalvm.AddTableNode($(Build-GraalVMTable)) $graalvm.AddTable($(Build-GraalVMTable))
# Toolcache # Toolcache
$toolcache = $installedSoftware.AddHeaderNode("Cached Tools") $toolcache = $installedSoftware.AddHeader("Cached Tools")
$toolcache.AddNodes($(Build-ToolcacheSection)) $toolcache.AddNodes($(Build-ToolcacheSection))
# Rust # Rust
$rust = $installedSoftware.AddHeaderNode("Rust Tools") $rust = $installedSoftware.AddHeader("Rust Tools")
$rust.AddToolNode("Cargo", $(Get-RustCargoVersion)) $rust.AddToolVersion("Cargo", $(Get-RustCargoVersion))
$rust.AddToolNode("Rust", $(Get-RustVersion)) $rust.AddToolVersion("Rust", $(Get-RustVersion))
$rust.AddToolNode("Rustdoc", $(Get-RustdocVersion)) $rust.AddToolVersion("Rustdoc", $(Get-RustdocVersion))
$rust.AddToolNode("Rustup", $(Get-RustupVersion)) $rust.AddToolVersion("Rustup", $(Get-RustupVersion))
$rustPackages = $rust.AddHeaderNode("Packages") $rustPackages = $rust.AddHeader("Packages")
$rustPackages.AddToolNode("Bindgen", $(Get-Bindgen)) $rustPackages.AddToolVersion("Bindgen", $(Get-Bindgen))
$rustPackages.AddToolNode("Cargo-audit", $(Get-Cargoaudit)) $rustPackages.AddToolVersion("Cargo-audit", $(Get-Cargoaudit))
$rustPackages.AddToolNode("Cargo-outdated", $(Get-Cargooutdated)) $rustPackages.AddToolVersion("Cargo-outdated", $(Get-Cargooutdated))
$rustPackages.AddToolNode("Cbindgen", $(Get-Cbindgen)) $rustPackages.AddToolVersion("Cbindgen", $(Get-Cbindgen))
$rustPackages.AddToolNode("Clippy", $(Get-RustClippyVersion)) $rustPackages.AddToolVersion("Clippy", $(Get-RustClippyVersion))
$rustPackages.AddToolNode("Rustfmt", $(Get-RustfmtVersion)) $rustPackages.AddToolVersion("Rustfmt", $(Get-RustfmtVersion))
# PowerShell # PowerShell
$powerShell = $installedSoftware.AddHeaderNode("PowerShell Tools") $powerShell = $installedSoftware.AddHeader("PowerShell Tools")
$powerShell.AddToolNode("PowerShell", $(Get-PowershellVersion)) $powerShell.AddToolVersion("PowerShell", $(Get-PowershellVersion))
$powerShellModules = $powerShell.AddHeaderNode("PowerShell Modules") $powerShellModules = $powerShell.AddHeader("PowerShell Modules")
$powerShellModules.AddNodes($(Get-PowerShellModules)) $powerShellModules.AddNodes($(Get-PowerShellModules))
# Web Servers # Web Servers
$webServers = $installedSoftware.AddHeaderNode("Web Servers") $webServers = $installedSoftware.AddHeader("Web Servers")
$webServers.AddTableNode($(Build-WebServersSection)) $webServers.AddTable($(Build-WebServersSection))
# Xamarin section # Xamarin section
$xamarin = $installedSoftware.AddHeaderNode("Xamarin") $xamarin = $installedSoftware.AddHeader("Xamarin")
$vsForMac = $xamarin.AddHeaderNode("Visual Studio for Mac") $vsForMac = $xamarin.AddHeader("Visual Studio for Mac")
$vsForMac.AddTableNode($(Build-VSMacTable)) $vsForMac.AddTable($(Build-VSMacTable))
if (-not $os.IsCatalina) { if (-not $os.IsCatalina) {
$note = $note =
@@ -211,60 +211,60 @@ To use Visual Studio 2019 by default rename the app:
mv "/Applications/Visual Studio.app" "/Applications/Visual Studio 2022.app" mv "/Applications/Visual Studio.app" "/Applications/Visual Studio 2022.app"
mv "/Applications/Visual Studio 2019.app" "/Applications/Visual Studio.app" mv "/Applications/Visual Studio 2019.app" "/Applications/Visual Studio.app"
'@ '@
$vsForMacNotes = $vsForMac.AddHeaderNode("Notes") $vsForMacNotes = $vsForMac.AddHeader("Notes")
$vsForMacNotes.AddNoteNode($note) $vsForMacNotes.AddNote($note)
} }
$xamarinBundles = $xamarin.AddHeaderNode("Xamarin bundles") $xamarinBundles = $xamarin.AddHeader("Xamarin bundles")
$xamarinBundles.AddTableNode($(Build-XamarinTable)) $xamarinBundles.AddTable($(Build-XamarinTable))
$unitTestFramework = $xamarin.AddHeaderNode("Unit Test Framework") $unitTestFramework = $xamarin.AddHeader("Unit Test Framework")
$unitTestFramework.AddToolNode("NUnit", $(Get-NUnitVersion)) $unitTestFramework.AddToolVersion("NUnit", $(Get-NUnitVersion))
# Xcode section # Xcode section
$xcode = $installedSoftware.AddHeaderNode("Xcode") $xcode = $installedSoftware.AddHeader("Xcode")
# First run doesn't provide full data about devices and runtimes # First run doesn't provide full data about devices and runtimes
Get-XcodeInfoList | Out-Null Get-XcodeInfoList | Out-Null
$xcodeInfo = Get-XcodeInfoList $xcodeInfo = Get-XcodeInfoList
$xcode.AddTableNode($(Build-XcodeTable $xcodeInfo)) $xcode.AddTable($(Build-XcodeTable $xcodeInfo))
$xcodeTools = $xcode.AddHeaderNode("Xcode Support Tools") $xcodeTools = $xcode.AddHeader("Xcode Support Tools")
$xcodeTools.AddNodes($(Build-XcodeSupportToolsSection)) $xcodeTools.AddNodes($(Build-XcodeSupportToolsSection))
$installedSdks = $xcode.AddHeaderNode("Installed SDKs") $installedSdks = $xcode.AddHeader("Installed SDKs")
$installedSdks.AddTableNode($(Build-XcodeSDKTable $xcodeInfo)) $installedSdks.AddTable($(Build-XcodeSDKTable $xcodeInfo))
$installedSimulators = $xcode.AddHeaderNode("Installed Simulators") $installedSimulators = $xcode.AddHeader("Installed Simulators")
$installedSimulators.AddTableNode($(Build-XcodeSimulatorsTable $xcodeInfo)) $installedSimulators.AddTable($(Build-XcodeSimulatorsTable $xcodeInfo))
# Android section # Android section
$android = $installedSoftware.AddHeaderNode("Android") $android = $installedSoftware.AddHeader("Android")
$androidTable = Build-AndroidTable $androidTable = Build-AndroidTable
if ($os.IsCatalina) { if ($os.IsCatalina) {
$androidTable += Get-IntelHaxmVersion $androidTable += Get-IntelHaxmVersion
} }
$android.AddTableNode($androidTable) $android.AddTable($androidTable)
$androidEnv = $android.AddHeaderNode("Environment variables") $androidEnv = $android.AddHeader("Environment variables")
$androidEnv.AddTableNode($(Build-AndroidEnvironmentTable)) $androidEnv.AddTable($(Build-AndroidEnvironmentTable))
$miscellaneous = $installedSoftware.AddHeaderNode("Miscellaneous") $miscellaneous = $installedSoftware.AddHeader("Miscellaneous")
$miscellaneous.AddToolNode("libXext", $(Get-LibXextVersion)) $miscellaneous.AddToolVersion("libXext", $(Get-LibXextVersion))
$miscellaneous.AddToolNode("libXft", $(Get-LibXftVersion)) $miscellaneous.AddToolVersion("libXft", $(Get-LibXftVersion))
$miscellaneous.AddToolNode("Tcl/Tk", $(Get-TclTkVersion)) $miscellaneous.AddToolVersion("Tcl/Tk", $(Get-TclTkVersion))
$miscellaneous.AddToolNode("Zlib", $(Get-ZlibVersion)) $miscellaneous.AddToolVersion("Zlib", $(Get-ZlibVersion))
if ($os.IsMonterey) { if ($os.IsMonterey) {
$miscellaneousEnv = $miscellaneous.AddHeaderNode("Environment variables") $miscellaneousEnv = $miscellaneous.AddHeader("Environment variables")
$miscellaneousEnv.AddTableNode($(Build-MiscellaneousEnvironmentTable)) $miscellaneousEnv.AddTable($(Build-MiscellaneousEnvironmentTable))
$notes = @' $notes = @'
If you want to use Parallels Desktop you should download a package from URL stored in If you want to use Parallels Desktop you should download a package from URL stored in
PARALLELS_DMG_URL environment variable. A system extension is allowed for this version. PARALLELS_DMG_URL environment variable. A system extension is allowed for this version.
'@ '@
$miscellaneousEnvNotes = $miscellaneousEnv.AddHeaderNode("Notes") $miscellaneousEnvNotes = $miscellaneousEnv.AddHeader("Notes")
$miscellaneousEnvNotes.AddNoteNode($notes) $miscellaneousEnvNotes.AddNote($notes)
} }
# #

12
images/macos/software-report/SoftwareReport.Toolcache.psm1
View File

@@ -35,11 +35,11 @@ function Get-ToolcacheGoVersions {
function Build-ToolcacheSection { function Build-ToolcacheSection {
return @( return @(
[ToolVersionsNode]::new("Ruby", $(Get-ToolcacheRubyVersions), '^\d+\.\d+', $false), [ToolVersionsListNode]::new("Ruby", $(Get-ToolcacheRubyVersions), '^\d+\.\d+', $false),
[ToolVersionsNode]::new("Python", $(Get-ToolcachePythonVersions), '^\d+\.\d+', $false), [ToolVersionsListNode]::new("Python", $(Get-ToolcachePythonVersions), '^\d+\.\d+', $false),
[ToolVersionsNode]::new("PyPy", $(Get-ToolcachePyPyVersions), '^\d+\.\d+', $false), [ToolVersionsListNode]::new("PyPy", $(Get-ToolcachePyPyVersions), '^\d+\.\d+', $false),
[ToolVersionsNode]::new("Node.js", $(Get-ToolcacheNodeVersions), '^\d+', $false), [ToolVersionsListNode]::new("Node.js", $(Get-ToolcacheNodeVersions), '^\d+', $false),
[ToolVersionsNode]::new("Go", $(Get-ToolcacheGoVersions), '^\d+\.\d+', $false) [ToolVersionsListNode]::new("Go", $(Get-ToolcacheGoVersions), '^\d+\.\d+', $false)
) )
} }
@@ -48,6 +48,6 @@ function Get-PowerShellModules {
$modules | ForEach-Object { $modules | ForEach-Object {
$moduleName = $_ $moduleName = $_
$moduleVersions = Get-Module -Name $moduleName -ListAvailable | Select-Object -ExpandProperty Version | Sort-Object -Unique $moduleVersions = Get-Module -Name $moduleName -ListAvailable | Select-Object -ExpandProperty Version | Sort-Object -Unique
return [ToolVersionsNode]::new($moduleName, $moduleVersions, '^\d+', $true) return [ToolVersionsListNode]::new($moduleName, $moduleVersions, '^\d+', $true)
} }
} }

8
images/macos/software-report/SoftwareReport.Xcode.psm1
View File

@@ -237,8 +237,8 @@ function Build-XcodeSupportToolsSection {
$xcpretty = Run-Command "xcpretty --version" $xcpretty = Run-Command "xcpretty --version"
$xcversion = Run-Command "xcversion --version" | Select-String "^[0-9]" $xcversion = Run-Command "xcversion --version" | Select-String "^[0-9]"
$toolNodes += [ToolNode]::new("xcpretty", $xcpretty) $toolNodes += [ToolVersionNode]::new("xcpretty", $xcpretty)
$toolNodes += [ToolNode]::new("xcversion", $xcversion) $toolNodes += [ToolVersionNode]::new("xcversion", $xcversion)
$nomadOutput = Run-Command "gem list nomad-cli" $nomadOutput = Run-Command "gem list nomad-cli"
$nomadCLI = [regex]::matches($nomadOutput, "(\d+.){2}\d+").Value $nomadCLI = [regex]::matches($nomadOutput, "(\d+.){2}\d+").Value
@@ -246,8 +246,8 @@ function Build-XcodeSupportToolsSection {
$nomadShenzhen = [regex]::matches($nomadShenzhenOutput, "(\d+.){2}\d+").Value $nomadShenzhen = [regex]::matches($nomadShenzhenOutput, "(\d+.){2}\d+").Value
if ($os.IsLessThanMonterey) { if ($os.IsLessThanMonterey) {
$toolNodes += [ToolNode]::new("Nomad CLI", $nomadCLI) $toolNodes += [ToolVersionNode]::new("Nomad CLI", $nomadCLI)
$toolNodes += [ToolNode]::new("Nomad shenzhen CLI", $nomadShenzhen) $toolNodes += [ToolVersionNode]::new("Nomad shenzhen CLI", $nomadShenzhen)
} }
return $toolNodes return $toolNodes