wehub-resource-sync
588 lines
16 KiB
PowerShell
588 lines
16 KiB
PowerShell
[CmdletBinding()]
|
|
param(
|
|
[ValidateSet('Table', 'Json', 'Markdown')]
|
|
[string]$OutputFormat = 'Table',
|
|
|
|
[switch]$IncludeEnglish,
|
|
|
|
[switch]$OnlyIncomplete,
|
|
|
|
[string]$OutputPath
|
|
)
|
|
|
|
Set-StrictMode -Version Latest
|
|
$ErrorActionPreference = 'Stop'
|
|
|
|
Import-Module (Join-Path $PSScriptRoot 'Languages\LanguageData.psm1') -Force
|
|
. (Join-Path $PSScriptRoot 'Languages\TranslationJsonTools.ps1')
|
|
|
|
function Read-LanguageMap {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$Path
|
|
)
|
|
|
|
if (-not (Test-Path -Path $Path -PathType Leaf)) {
|
|
return (New-OrderedStringMap)
|
|
}
|
|
|
|
return (Read-OrderedJsonMap -Path $Path)
|
|
}
|
|
|
|
function Get-LanguageMapSections {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[System.Collections.IDictionary]$Map
|
|
)
|
|
|
|
$sections = Split-TranslationMapAtBoundary -Map $Map
|
|
$fullMap = Join-TranslationMapWithBoundary -ActiveMap $sections.ActiveMap -LegacyMap $sections.LegacyMap
|
|
|
|
return [pscustomobject]@{
|
|
HasBoundary = $sections.HasBoundary
|
|
FullMap = $fullMap
|
|
ActiveMap = $sections.ActiveMap
|
|
LegacyMap = $sections.LegacyMap
|
|
}
|
|
}
|
|
|
|
function Get-PercentageNumber {
|
|
param(
|
|
[AllowNull()]
|
|
[object]$Value
|
|
)
|
|
|
|
if ($null -eq $Value) {
|
|
return $null
|
|
}
|
|
|
|
$text = [string]$Value
|
|
if ([string]::IsNullOrWhiteSpace($text)) {
|
|
return $null
|
|
}
|
|
|
|
$trimmed = $text.Trim()
|
|
if ($trimmed.EndsWith('%', [System.StringComparison]::Ordinal)) {
|
|
$trimmed = $trimmed.Substring(0, $trimmed.Length - 1)
|
|
}
|
|
|
|
$result = 0
|
|
if ([int]::TryParse($trimmed, [ref]$result)) {
|
|
return $result
|
|
}
|
|
|
|
return $null
|
|
}
|
|
|
|
function Get-CompletionPercentage {
|
|
param(
|
|
[int]$Completed,
|
|
[int]$Total
|
|
)
|
|
|
|
if ($Total -le 0) {
|
|
return 0
|
|
}
|
|
|
|
if ($Completed -ge $Total) {
|
|
return 100
|
|
}
|
|
|
|
$rounded = [int][Math]::Round(($Completed / $Total) * 100, 0, [MidpointRounding]::AwayFromZero)
|
|
return [Math]::Min($rounded, 99)
|
|
}
|
|
|
|
function Test-KnownPlaceholderLocale {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$LanguageCode
|
|
)
|
|
|
|
return $false
|
|
}
|
|
|
|
function Test-IntentionalSourceEqualValue {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$LanguageCode,
|
|
|
|
[Parameter(Mandatory = $true)]
|
|
[AllowEmptyString()]
|
|
[string]$SourceValue,
|
|
|
|
[Parameter(Mandatory = $false)]
|
|
[AllowEmptyString()]
|
|
[string]$TargetValue = ''
|
|
)
|
|
|
|
if ($SourceValue -in @(
|
|
'MSI',
|
|
'MSIX',
|
|
'OK',
|
|
'UniGetUI',
|
|
'UniGetUI - {0} {1}',
|
|
'your@email.com',
|
|
'{0}: {1}',
|
|
'{0}: {1}, {2}'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'it' -and $SourceValue -ceq 'No' -and $TargetValue -ceq 'No') {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'ca' -and $SourceValue -ceq $TargetValue -and $SourceValue -in @(
|
|
'1 - Errors',
|
|
'Error',
|
|
'Global',
|
|
'Local',
|
|
'Manifest',
|
|
'Manifests',
|
|
'No',
|
|
'Notes:',
|
|
'Text'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'pt_PT' -and $SourceValue -ceq $TargetValue -and $SourceValue -in @(
|
|
'Global',
|
|
'Local'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'hr' -and $SourceValue -ceq $TargetValue -and $SourceValue -in @(
|
|
'Manifest',
|
|
'Status',
|
|
'URL'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'es' -and $SourceValue -ceq $TargetValue -and $SourceValue -in @(
|
|
'Error',
|
|
'Global',
|
|
'Local',
|
|
'No',
|
|
'URL'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'es-MX' -and $SourceValue -ceq $TargetValue -and $SourceValue -in @(
|
|
'Error',
|
|
'Global',
|
|
'Local',
|
|
'No',
|
|
'URL',
|
|
'Url'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'fr' -and $SourceValue -ceq $TargetValue -and $SourceValue -in @(
|
|
'Ascendant',
|
|
'Descendant',
|
|
'Global',
|
|
'Local',
|
|
'Portable',
|
|
'Source',
|
|
'Sources',
|
|
'Verbose',
|
|
'Version',
|
|
'installation',
|
|
'option',
|
|
'version {0}',
|
|
'{0} minutes'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'nl' -and $SourceValue -ceq $TargetValue -and $SourceValue -in @(
|
|
'1 week',
|
|
'Filters',
|
|
'Manifest',
|
|
'Status',
|
|
'Updates',
|
|
'URL',
|
|
'update',
|
|
'website',
|
|
'{0} status'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'sk' -and $SourceValue -ceq $TargetValue -and $SourceValue -in @(
|
|
'Manifest',
|
|
'Text'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'de' -and $SourceValue -ceq $TargetValue -and $SourceValue -in @(
|
|
'Global',
|
|
'Manifest',
|
|
'Name',
|
|
'Repository',
|
|
'Start',
|
|
'Status',
|
|
'Text',
|
|
'Updates',
|
|
'URL',
|
|
'Verbose',
|
|
'Version',
|
|
'Version:',
|
|
'optional',
|
|
'{package} Installation',
|
|
'{package} Update'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'sv' -and $SourceValue -ceq $TargetValue -and $SourceValue -in @(
|
|
'Global',
|
|
'Manifest',
|
|
'Start',
|
|
'Status',
|
|
'Text',
|
|
'Version',
|
|
'Version:',
|
|
'installation',
|
|
'version {0}',
|
|
'{0} installation',
|
|
'{0} status',
|
|
'{pm} version:'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'id' -and $SourceValue -ceq $TargetValue -and $SourceValue -in @(
|
|
'Global',
|
|
'Grid',
|
|
'Manifest',
|
|
'Status',
|
|
'URL',
|
|
'Verbose',
|
|
'{0} status'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
if ($LanguageCode -ceq 'fil' -and $SourceValue -ceq $TargetValue -and $SourceValue -in @(
|
|
'Android Subsystem',
|
|
'Default',
|
|
'Error',
|
|
'Global',
|
|
'Grid',
|
|
'Machine | Global',
|
|
'Manifest',
|
|
'OK',
|
|
'Ok',
|
|
'Package',
|
|
'Password',
|
|
'Portable',
|
|
'Portable mode',
|
|
'PreRelease',
|
|
'Repository',
|
|
'Source',
|
|
'Source:',
|
|
'Telemetry',
|
|
'Text',
|
|
'URL',
|
|
'UniGetUI',
|
|
'UniGetUI - {0} {1}',
|
|
'User',
|
|
'Username',
|
|
'Verbose',
|
|
'website',
|
|
'library'
|
|
)) {
|
|
return $true
|
|
}
|
|
|
|
return $false
|
|
}
|
|
|
|
. (Join-Path $PSScriptRoot 'Languages\IntentionalSourceEqualValues.ps1')
|
|
|
|
function Get-TranslationStatusRow {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$LanguageCode,
|
|
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$LanguageName,
|
|
|
|
[Parameter(Mandatory = $true)]
|
|
[System.Collections.IDictionary]$NeutralMap,
|
|
|
|
[Parameter(Mandatory = $true)]
|
|
[System.Collections.IDictionary]$NeutralLegacyMap,
|
|
|
|
[Parameter(Mandatory = $true)]
|
|
[System.Collections.IDictionary]$TargetMap,
|
|
|
|
[Parameter(Mandatory = $true)]
|
|
[System.Collections.IDictionary]$TargetLegacyMap,
|
|
|
|
[AllowNull()]
|
|
[Nullable[int]]$StoredPercentage,
|
|
|
|
[Parameter(Mandatory = $true)]
|
|
[bool]$HasFile,
|
|
|
|
[Parameter(Mandatory = $true)]
|
|
[bool]$HasBoundary
|
|
)
|
|
|
|
$totalKeys = $NeutralMap.Count
|
|
$missingKeys = 0
|
|
$emptyKeys = 0
|
|
$sourceEqualKeys = 0
|
|
$translatedKeys = 0
|
|
$extraKeys = 0
|
|
|
|
foreach ($entry in $NeutralMap.GetEnumerator()) {
|
|
$key = [string]$entry.Key
|
|
$sourceValue = if ($null -eq $entry.Value) { '' } else { [string]$entry.Value }
|
|
|
|
if (-not $TargetMap.Contains($key)) {
|
|
$missingKeys += 1
|
|
continue
|
|
}
|
|
|
|
$targetValue = if ($null -eq $TargetMap[$key]) { '' } else { [string]$TargetMap[$key] }
|
|
if ([string]::IsNullOrWhiteSpace($targetValue)) {
|
|
$emptyKeys += 1
|
|
continue
|
|
}
|
|
|
|
if ($LanguageCode -ne 'en' -and $targetValue -ceq $sourceValue) {
|
|
if (Test-IntentionalSourceEqualValue -LanguageCode $LanguageCode -SourceValue $sourceValue -TargetValue $targetValue) {
|
|
$translatedKeys += 1
|
|
continue
|
|
}
|
|
|
|
$sourceEqualKeys += 1
|
|
continue
|
|
}
|
|
|
|
$translatedKeys += 1
|
|
}
|
|
|
|
$knownKeys = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::Ordinal)
|
|
foreach ($key in $NeutralMap.Keys) {
|
|
[void]$knownKeys.Add([string]$key)
|
|
}
|
|
|
|
foreach ($key in $NeutralLegacyMap.Keys) {
|
|
[void]$knownKeys.Add([string]$key)
|
|
}
|
|
|
|
foreach ($key in $TargetMap.Keys) {
|
|
if (-not $knownKeys.Contains([string]$key)) {
|
|
$extraKeys += 1
|
|
}
|
|
}
|
|
|
|
$isKnownPlaceholder = Test-KnownPlaceholderLocale -LanguageCode $LanguageCode
|
|
$sourceEqualThreshold = if ($totalKeys -le 0) {
|
|
0
|
|
}
|
|
else {
|
|
[int][Math]::Max(
|
|
[double]($totalKeys - 5),
|
|
[Math]::Ceiling($totalKeys * 0.98)
|
|
)
|
|
}
|
|
|
|
$potentialFallbackRegression = $HasFile -and -not $isKnownPlaceholder -and $sourceEqualKeys -ge $sourceEqualThreshold -and $translatedKeys -le 5
|
|
|
|
$completion = Get-CompletionPercentage -Completed $translatedKeys -Total $totalKeys
|
|
$storedText = if ($null -eq $StoredPercentage) { '' } else { '{0}%' -f $StoredPercentage }
|
|
$delta = if ($null -eq $StoredPercentage) { $null } else { $completion - $StoredPercentage }
|
|
|
|
return [pscustomobject]@{
|
|
Code = $LanguageCode
|
|
Language = $LanguageName
|
|
HasFile = $HasFile
|
|
HasBoundary = $HasBoundary
|
|
TotalKeys = $totalKeys
|
|
ActiveKeys = $totalKeys
|
|
Legacy = $TargetLegacyMap.Count
|
|
Translated = $translatedKeys
|
|
Missing = $missingKeys
|
|
Empty = $emptyKeys
|
|
SourceEqual = $sourceEqualKeys
|
|
Untranslated = $missingKeys + $emptyKeys + $sourceEqualKeys
|
|
Extra = $extraKeys
|
|
Completion = '{0}%' -f $completion
|
|
CompletionValue = $completion
|
|
Stored = $storedText
|
|
StoredValue = $StoredPercentage
|
|
Delta = $delta
|
|
KnownPlaceholder = $isKnownPlaceholder
|
|
PotentialFallbackRegression = $potentialFallbackRegression
|
|
}
|
|
}
|
|
|
|
function Convert-RowsToMarkdown {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[object[]]$Rows
|
|
)
|
|
|
|
$lines = New-Object System.Collections.Generic.List[string]
|
|
$lines.Add('| Code | Language | Completion | Stored | Delta | Translated | Missing | Empty | Source Equal | Extra |')
|
|
$lines.Add('| :-- | :-- | --: | --: | --: | --: | --: | --: | --: | --: |')
|
|
|
|
foreach ($row in $Rows) {
|
|
$deltaText = if ($null -eq $row.Delta) { '' } elseif ($row.Delta -gt 0) { '+{0}' -f $row.Delta } else { [string]$row.Delta }
|
|
$storedText = if ([string]::IsNullOrWhiteSpace([string]$row.Stored)) { '' } else { [string]$row.Stored }
|
|
$lines.Add("| $($row.Code) | $($row.Language) | $($row.Completion) | $storedText | $deltaText | $($row.Translated) | $($row.Missing) | $($row.Empty) | $($row.SourceEqual) | $($row.Extra) |")
|
|
}
|
|
|
|
return ($lines -join [Environment]::NewLine)
|
|
}
|
|
|
|
function Write-OutputContent {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[AllowEmptyString()]
|
|
[string]$Content
|
|
)
|
|
|
|
if ([string]::IsNullOrWhiteSpace($OutputPath)) {
|
|
Write-Output $Content
|
|
return
|
|
}
|
|
|
|
$resolvedOutputPath = [System.IO.Path]::GetFullPath($OutputPath)
|
|
$directory = Split-Path -Path $resolvedOutputPath -Parent
|
|
if (-not [string]::IsNullOrWhiteSpace($directory)) {
|
|
New-Item -Path $directory -ItemType Directory -Force | Out-Null
|
|
}
|
|
|
|
$encoding = [System.Text.UTF8Encoding]::new($false)
|
|
[System.IO.File]::WriteAllText($resolvedOutputPath, $Content + [Environment]::NewLine, $encoding)
|
|
Write-Output "Wrote translation status summary to: $resolvedOutputPath"
|
|
}
|
|
|
|
function Get-OverviewLines {
|
|
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[object[]]$Rows
|
|
)
|
|
|
|
if ($Rows.Count -eq 0) {
|
|
return @('Languages: 0', 'Incomplete: 0', 'Fully translated: 0')
|
|
}
|
|
|
|
$incompleteCount = @($Rows | Where-Object { $_.Untranslated -gt 0 }).Count
|
|
$completeCount = @($Rows | Where-Object { $_.Untranslated -eq 0 }).Count
|
|
$totalUntranslated = ($Rows | Measure-Object -Property Untranslated -Sum).Sum
|
|
$totalMissing = ($Rows | Measure-Object -Property Missing -Sum).Sum
|
|
$totalEmpty = ($Rows | Measure-Object -Property Empty -Sum).Sum
|
|
$totalSourceEqual = ($Rows | Measure-Object -Property SourceEqual -Sum).Sum
|
|
$placeholderRows = @($Rows | Where-Object { $_.KnownPlaceholder })
|
|
$potentialRegressionRows = @($Rows | Where-Object { $_.PotentialFallbackRegression })
|
|
|
|
$lines = New-Object System.Collections.Generic.List[string]
|
|
$lines.Add(('Languages: {0}' -f $Rows.Count))
|
|
$lines.Add(('Incomplete: {0}' -f $incompleteCount))
|
|
$lines.Add(('Fully translated: {0}' -f $completeCount))
|
|
$lines.Add(('Outstanding entries: {0} (missing {1}, empty {2}, source-equal {3})' -f $totalUntranslated, $totalMissing, $totalEmpty, $totalSourceEqual))
|
|
|
|
if ($placeholderRows.Count -gt 0) {
|
|
$lines.Add(('Known placeholders: {0}' -f (($placeholderRows | ForEach-Object { $_.Code }) -join ', ')))
|
|
}
|
|
|
|
if ($potentialRegressionRows.Count -gt 0) {
|
|
$lines.Add(('Potential fallback regressions: {0}' -f (($potentialRegressionRows | ForEach-Object { $_.Code }) -join ', ')))
|
|
}
|
|
|
|
return $lines.ToArray()
|
|
}
|
|
|
|
$languagesDirectory = Get-LanguagesDirectoryPath
|
|
$neutralPath = Join-Path $languagesDirectory 'lang_en.json'
|
|
if (-not (Test-Path -Path $neutralPath -PathType Leaf)) {
|
|
throw "Neutral language file not found: $neutralPath"
|
|
}
|
|
|
|
$neutralSections = Get-LanguageMapSections -Map (Read-LanguageMap -Path $neutralPath)
|
|
$neutralMap = $neutralSections.ActiveMap
|
|
$neutralLegacyMap = $neutralSections.LegacyMap
|
|
$languageReference = Get-LanguageReference
|
|
$storedPercentages = Get-TranslatedPercentages
|
|
$rows = New-Object System.Collections.Generic.List[object]
|
|
|
|
foreach ($entry in $languageReference.GetEnumerator()) {
|
|
$languageCode = [string]$entry.Key
|
|
if ($languageCode -eq 'default') {
|
|
continue
|
|
}
|
|
|
|
if (-not $IncludeEnglish.IsPresent -and $languageCode -eq 'en') {
|
|
continue
|
|
}
|
|
|
|
$languageFilePath = Join-Path $languagesDirectory ("lang_{0}.json" -f $languageCode)
|
|
$hasFile = Test-Path -Path $languageFilePath -PathType Leaf
|
|
$targetSections = if ($hasFile) { Get-LanguageMapSections -Map (Read-LanguageMap -Path $languageFilePath) } else { [pscustomobject]@{ HasBoundary = $false; FullMap = (New-OrderedStringMap); ActiveMap = (New-OrderedStringMap); LegacyMap = (New-OrderedStringMap) } }
|
|
$storedPercentage = if ($storedPercentages.Contains($languageCode)) { Get-PercentageNumber -Value $storedPercentages[$languageCode] } elseif ($languageCode -eq 'en') { 100 } else { $null }
|
|
|
|
$row = Get-TranslationStatusRow -LanguageCode $languageCode -LanguageName ([string]$entry.Value) -NeutralMap $neutralMap -NeutralLegacyMap $neutralLegacyMap -TargetMap $targetSections.FullMap -TargetLegacyMap $targetSections.LegacyMap -StoredPercentage $storedPercentage -HasFile:$hasFile -HasBoundary:$targetSections.HasBoundary
|
|
if ($OnlyIncomplete.IsPresent -and $row.Untranslated -eq 0) {
|
|
continue
|
|
}
|
|
|
|
$rows.Add($row)
|
|
}
|
|
|
|
$orderedRows = @(
|
|
$rows |
|
|
Sort-Object @{ Expression = 'CompletionValue'; Descending = $false }, @{ Expression = 'Code'; Descending = $false }
|
|
)
|
|
|
|
switch ($OutputFormat) {
|
|
'Json' {
|
|
$json = if ($orderedRows.Count -eq 0) {
|
|
'[]'
|
|
}
|
|
else {
|
|
$orderedRows | ConvertTo-Json -Depth 5
|
|
}
|
|
|
|
Write-OutputContent -Content $json
|
|
}
|
|
'Markdown' {
|
|
$overview = Get-OverviewLines -Rows $orderedRows
|
|
$markdownLines = @(
|
|
'## Translation Status Overview',
|
|
''
|
|
) + @($overview | ForEach-Object { '- ' + $_ }) + @(
|
|
'',
|
|
(Convert-RowsToMarkdown -Rows $orderedRows)
|
|
)
|
|
$markdown = $markdownLines -join [Environment]::NewLine
|
|
Write-OutputContent -Content $markdown
|
|
}
|
|
default {
|
|
$overview = Get-OverviewLines -Rows $orderedRows
|
|
$tableText = $orderedRows |
|
|
Select-Object Code, Language, Completion, Stored, Delta, Translated, Missing, Empty, SourceEqual, Extra |
|
|
Format-Table -AutoSize |
|
|
Out-String
|
|
$content = (@(
|
|
$overview
|
|
) + @(
|
|
'',
|
|
$tableText.TrimEnd()
|
|
)) -join [Environment]::NewLine
|
|
Write-OutputContent -Content $content
|
|
}
|
|
}
|