✨ (HugoHelpers.ps1, Utilities.ps1): add Update-HashtableList function and ConvertTo-CamelCase utility

✅ (Update-ReourcesFrontMatter.ps1): improve progress logging and refactor resource loading

Introduce the `Update-HashtableList` function to handle ordered
dictionaries, allowing for more complex data structures in front matter
updates. Add `ConvertTo-CamelCase` utility to facilitate string
manipulation. Enhance progress logging in `Update-ReourcesFrontMatter.ps1`
by calculating and displaying progress in 10% increments, improving
user feedback during long operations. These changes aim to improve
functionality and user experience when managing markdown resources.

Author: MrHinsh

.powershell/_includes/HugoHelpers.ps1

@@ -115,6 +115,94 @@ function Update-Field {
     return 
 }
 
+function Update-HashtableList {
+    param (
+        [Parameter(Mandatory = $true)]
+        [System.Collections.Specialized.OrderedDictionary]$frontMatter,
+        [Parameter(Mandatory = $true)]
+        [string]$fieldName,
+        [Parameter(Mandatory = $true)]
+        [AllowEmptyCollection()]
+        [hashtable[]]$values, # Accepts only an array of hashtables
+        [string]$addAfter = $null,
+        [string]$addBefore = $null,
+        [switch]$Overwrite
+    )
+
+    # Ensure values are always an array and remove any null values
+    $values = @($values | Where-Object { $_ -ne $null })
+
+    # Convert all input hashtables to ordered hashtables while keeping their order intact
+    $values = $values | ForEach-Object {
+        if ($_ -is [System.Collections.Specialized.OrderedDictionary]) { $_ }
+        else { 
+            $orderedHash = [ordered]@{}
+            $_.GetEnumerator() | ForEach-Object { $orderedHash[$_.Key] = $_.Value }
+            $orderedHash
+        }
+    }
+
+    # If the field doesn't exist, create it with position handling
+    if (-not $frontMatter.Contains($fieldName)) {
+        $index = $null
+        if ($addAfter -and $frontMatter.Contains($addAfter)) {
+            $index = $frontMatter.Keys.IndexOf($addAfter) + 1
+        }
+        elseif ($addBefore -and $frontMatter.Contains($addBefore)) {
+            $index = $frontMatter.Keys.IndexOf($addBefore)
+        }
+
+        if ($index -ne $null) {
+            $frontMatter.Insert($index, $fieldName, $values)
+        }
+        else {
+            $frontMatter[$fieldName] = $values
+        }
+
+        Write-Debug "$fieldName added"
+    }
+    else {
+        # Ensure the field is always an array
+        if (-not ($frontMatter[$fieldName] -is [System.Collections.IEnumerable])) {
+            $frontMatter[$fieldName] = @($frontMatter[$fieldName])
+        }
+
+        if ($Overwrite) {
+            $frontMatter[$fieldName] = $values
+        }
+        else {
+            # Preserve the existing values as an ordered array
+            $existingValues = @($frontMatter[$fieldName])
+
+            # Create a lookup table of existing hashtables for deduplication
+            $existingHashtablesJson = @{}
+            foreach ($hash in $existingValues) {
+                $existingHashtablesJson[(ConvertTo-Json $hash -Compress)] = $true
+            }
+
+            # Append only unique hashtables in original order
+            foreach ($hash in $values) {
+                $hashJson = ConvertTo-Json $hash -Compress
+                if (-not $existingHashtablesJson.ContainsKey($hashJson)) {
+                    $existingHashtablesJson[$hashJson] = $true
+                    $existingValues += $hash
+                }
+            }
+
+            # Maintain the original order exactly
+            $frontMatter[$fieldName] = $existingValues
+            Write-Debug "$fieldName updated with new unique values"
+        }
+    }
+
+    # Ensure the field remains an array even if it has only one value
+    if ($frontMatter[$fieldName] -isnot [array]) {
+        $frontMatter[$fieldName] = @($frontMatter[$fieldName])
+    }
+}
+
+
+
 # Update-List function to have the same signature as Update-Field
 # Update-List -frontMatter $frontMatter -fieldName 'tags' -values @('DevOps', 'Agile', 'Scrum')
 function Update-StringList {

.powershell/_includes/Utilities.ps1

@@ -0,0 +1,23 @@
+
+
+function ConvertTo-CamelCase {
+    param (
+        [string]$Text
+    )
+
+    # Split words by spaces or non-alphanumeric characters
+    $words = $Text -split '\W+' | Where-Object { $_ -match '\w' }  # Remove empty values
+
+    if ($words.Count -eq 0) { return '' }  # Handle empty input
+
+    # Ensure first word is lowercase, and capitalize subsequent words properly
+    $camelCase = $words[0].ToLower() + ($words[1..($words.Count - 1)] | ForEach-Object {
+            if ($_.Length -gt 0) {
+                $_.Substring(0, 1).ToUpper() + $_.Substring(1).ToLower()
+            }
+        }) -join ''
+
+    return $camelCase
+}
+
+Write-Debug "Utilities.ps1 loaded"

.powershell/single-use/resources/Update-ReourcesFrontMatter.ps1

@@ -21,15 +21,23 @@ $Counter = 1
 $categoriesCatalog = Get-CatalogHashtable -Classification "categories"
 $tagsCatalog = Get-CatalogHashtable -Classification "tags"
 
+Write-InformationLog "Loading ({count}) markdown files...." -PropertyValues $resources.Count
+$resourceCount = $resources.Count
+$progressStep = [math]::Ceiling($resourceCount / 10)  # Calculate step for 10% progress
 $hugoMarkdownObjects = @()
-$TotalFiles = $resources.Count
-Write-InformationLog "Loading ({count}) markdown files...." -PropertyValues $TotalFiles
-$resources | ForEach-Object {
-    if ((Test-Path $_)) {
+
+$resources | ForEach-Object -Begin { $index = 0 } -Process {
+    if (Test-Path $_) {
         $hugoMarkdown = Get-HugoMarkdown -Path $_
         $hugoMarkdownObjects += $hugoMarkdown
     }
+
+    $index++
+    if ($index % $progressStep -eq 0 -or $index -eq $resourceCount) {
+        Write-InformationLog "Progress: $([math]::Round(($index / $resourceCount) * 100))% complete"
+    }
 }
+
 $TotalItems = $hugoMarkdownObjects.Count
 Write-InformationLog "Loaded ({count}) HugoMarkdown Objects." -PropertyValues $TotalItems
 ### FILTER hugoMarkdownObjects
@@ -213,13 +221,16 @@ while ($hugoMarkdownQueue.Count -gt 0 -or $hugoMarkdownBatchQueue.Count -gt 0) {
     $categoryClassification = Get-ClassificationsForType -updateMissing -ClassificationType "categories" -hugoMarkdown $hugoMarkdown
     $categoryClassificationOrdered = Get-ClassificationOrderedList -minScore 50 -byLevel -classifications $categoryClassification | Select-Object -First 3
     $categories = $categoryClassificationOrdered | ForEach-Object { $_.category }
-
     Update-StringList -frontMatter $hugoMarkdown.FrontMatter -fieldName 'categories' -values @($categories) -Overwrite
+    #$categoriesMeta = $categoryClassificationOrdered | ForEach-Object { [ordered]@{ category = $_.category; final_score = $_.final_score } }
+    #Update-HashtableList -frontMatter $hugoMarkdown.FrontMatter -fieldName 'categoriesMeta' -addAfter "categories" -values $categoriesMeta -Overwrite
     #-----------------Tags-------------------
     $tagClassification = Get-ClassificationsForType -updateMissing -ClassificationType "tags" -hugoMarkdown $hugoMarkdown
     $tagClassificationOrdered = Get-ClassificationOrderedList -minScore 70 -classifications $tagClassification | Select-Object -First 10
     $tags = $tagClassificationOrdered | ForEach-Object { $_.category }
     Update-StringList -frontMatter $hugoMarkdown.FrontMatter -fieldName 'tags' -values @($tags) -Overwrite
+    #$tagsMeta = $tagClassificationOrdered | ForEach-Object { [ordered]@{ category = $_.category; final_score = $_.final_score } }
+    #Update-HashtableList -frontMatter $hugoMarkdown.FrontMatter -fieldName 'tagsMeta' -addAfter "tags" -values $tagsMeta -Overwrite
     # =================COMPLETE===================
     $eeResult = Get-Classification -CacheFolder $hugoMarkdown.FolderPath  -ClassificationName "Engineering Excellence"
     $tlResult = Get-Classification -CacheFolder $hugoMarkdown.FolderPath  -ClassificationName "Technical Leadership"