#requires -Version 5.1

[CmdletBinding()]

param(

# Build task(s) to execute

[ArgumentCompleter({

param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameters)

$scriptPath = $commandAst.CommandElements[0].Extent.Text

$resolvedPath = Resolve-Path -Path $scriptPath -ErrorAction SilentlyContinue

if (-not $resolvedPath) { return }

$tokens = $null

$errors = $null

$ast = [System.Management.Automation.Language.Parser]::ParseFile(

$resolvedPath.Path, [ref]$tokens, [ref]$errors

)

$ast.FindAll(

{ param($node) $node -is [System.Management.Automation.Language.FunctionDefinitionAst] }, $false

) |

Where-Object { $_.Name -ne 'Invoke-Step' } |

ForEach-Object { $_.Name } |

Where-Object { $_ -like "$wordToComplete*" } |

ForEach-Object {

[System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)

}

})]

[string]$Task = 'Test',

# Bootstrap dependencies

[switch]$Bootstrap

)

$sut = Join-Path -Path $PSScriptRoot -ChildPath 'src'

$manifestPath = Join-Path -Path $sut -ChildPath 'psake.psd1'

$manifestData = Import-PowerShellDataFile -Path $manifestPath

$moduleVersion = $manifestData.ModuleVersion

$prerelease = $manifestData.PrivateData.PSData.Prerelease

$version = if ($prerelease) { "$moduleVersion-$prerelease" } else { $moduleVersion }

$outputDir = Join-Path -Path $PSScriptRoot -ChildPath 'output'

$outputNugetDir = Join-Path -Path $outputDir -ChildPath 'nuget'

$outputModDir = Join-Path -Path $outputDir -ChildPath 'psake'

$outputModVerDir = Join-Path -Path $outputModDir -ChildPath $moduleVersion

$outputManifest = Join-Path -Path $outputModVerDir -ChildPath 'psake.psd1'

$PSDefaultParameterValues = @{

'Get-Module:Verbose' = $false

'Remove-Module:Verbose' = $false

'Import-Module:Verbose' = $false

}

if ($Bootstrap) {

Get-PackageProvider -Name Nuget -ForceBootstrap > $null

Set-PSRepository -Name PSGallery -InstallationPolicy Trusted

if (-not (Get-Module -Name PSDepend -ListAvailable)) {

Install-Module -Name PSDepend -Repository PSGallery -Scope CurrentUser -Force

}

Import-Module -Name PSDepend -Verbose:$false

Invoke-PSDepend -Path './requirements.psd1' -Install -Import -Force -WarningAction SilentlyContinue

}

# Taken with love from Jaykul @ https://gist.github.com/Jaykul/e0c08be051bed56d62474ae12b9b1b8a

class DependsOn : System.Attribute {

[string[]]$Name

DependsOn([string[]]$name) {

$this.Name = $name

}

}

function Invoke-Step {

<#

.Synopsis

Runs a command, taking care to run it's dependencies first

.Description

Invoke-Step supports the [DependsOn("...")] attribute to allow you to write tasks or build steps that take dependencies on other tasks completing first.

When you invoke a step, dependencies are run first, recursively. The algorithm for this is depth-first and *very* naive. Don't build cycles!

.Example

function init {

param()

Write-Information "INITIALIZING build variables"

}

function update {

[DependsOn("init")]param()

Write-Information "UPDATING dependencies"

}

function build {

[DependsOn(("update","init"))]param()

Write-Information "BUILDING: $ModuleName from $Path"

}

Invoke-Step build -InformationAction continue

Defines three steps with dependencies, and invokes the "build" step.

Results in this output:

Invoking Step: init

Invoking Step: update

Invoking Step: build

#>

[CmdletBinding()]

param(

[string]$Step,

[string]$Script

)

begin {

# Source Build Scripts, if any

if ($Script) {

. $Script

}

# Don't reset on nested calls

if (((Get-PSCallStack).Command -eq 'Invoke-Step').Count -eq 1) {

$script:InvokedSteps = @()

}

}

end {

if ($stepCommand = Get-Command -Name $Step -CommandType Function) {

$dependencies = $stepCommand.ScriptBlock.Attributes.Where{ $_.TypeId.Name -eq 'DependsOn' }.Name

foreach ($dependency in $dependencies) {

if ($dependency -notin $script:InvokedSteps) {

Invoke-Step -Step $dependency

}

}

if ($Step -notin $script:InvokedSteps) {

Write-Host "Invoking Step: $Step" -ForegroundColor Cyan

try {

& $stepCommand

$script:InvokedSteps += $Step

} catch {

throw $_

}

}

} else {

throw "Could not find step [$Step]"

}

}

}

function Init {

[CmdletBinding()]

param()

Remove-Module -Name psake -Force -ErrorAction SilentlyContinue

Set-BuildEnvironment -Force

}

function Test {

[DependsOn(('Build', 'Analyze', 'Pester'))]

[CmdletBinding()]

param()

''

}

function Analyze {

[DependsOn('Init')]

[CmdletBinding()]

param()

$analysis = Invoke-ScriptAnalyzer -Path $sut -Recurse -Verbose:$false

$errors = $analysis | Where-Object { $_.Severity -eq 'Error' }

$warnings = $analysis | Where-Object { $_.Severity -eq 'Warning' }

if (($errors.Count -eq 0) -and ($warnings.Count -eq 0)) {

'PSScriptAnalyzer passed without errors or warnings'

}

if (@($errors).Count -gt 0) {

Write-Error -Message 'One or more Script Analyzer errors were found. Build cannot continue!'

$errors | Format-Table -AutoSize

}

if (@($warnings).Count -gt 0) {

Write-Warning -Message 'One or more Script Analyzer warnings were found. These should be corrected.'

$warnings | Format-Table -AutoSize

}

}

function Pester {

[DependsOn('Init')]

[CmdletBinding()]

param()

Import-Module -Name $outputManifest -Force

# Write the results where continuous integration can find them. The shared module

# workflow uploads ./tests/out/testResults.xml as an artifact and publishes it as a

# check, and azure-pipelines.yml has been looking for a results file for some time

# without one ever being produced.

#

# Configured through a PesterConfiguration rather than -OutputFile/-OutputFormat:

# those belong to Pester 5's Legacy parameter set and cannot be combined with the

# Simple set's -Path and -Output.

$testResultPath = Join-Path -Path $PSScriptRoot -ChildPath 'tests/out/testResults.xml'

$testResultDirectory = Split-Path -Path $testResultPath -Parent

if (-not (Test-Path -LiteralPath $testResultDirectory)) {

New-Item -Path $testResultDirectory -ItemType Directory -Force > $null

}

$pesterConfiguration = New-PesterConfiguration

$pesterConfiguration.Run.Path = './tests'

$pesterConfiguration.Run.PassThru = $true

$pesterConfiguration.Output.Verbosity = 'Detailed'

$pesterConfiguration.TestResult.Enabled = $true

$pesterConfiguration.TestResult.OutputPath = $testResultPath

$pesterConfiguration.TestResult.OutputFormat = 'NUnitXml'

$testResults = Invoke-Pester -Configuration $pesterConfiguration

if ($testResults.FailedCount -gt 0) {

throw "$($testResults.FailedCount) tests failed!"

}

}

function Clean {

[DependsOn('Init')]

[CmdletBinding()]

param()

if (Test-Path -Path $outputModVerDir) {

Remove-Item -Path $outputModVerDir -Recurse -Force > $null

}

}

function Build {

[DependsOn('Clean')]

[CmdletBinding()]

param()

if (-not (Test-Path -Path $outputDir)) {

New-Item -Path $outputDir -ItemType Directory > $null

}

New-Item -Path $outputModVerDir -ItemType Directory > $null

Copy-Item -Path (Join-Path -Path $sut -ChildPath *) -Destination $outputModVerDir -Recurse

Copy-Item -Path (Join-Path -Path $PSScriptRoot -ChildPath 'examples') -Destination $outputModVerDir -Recurse

}

function CreateMarkdownHelp {

[DependsOn('Init')]

[CmdletBinding()]

param()

$mdHelpPath = "$PSScriptRoot/docs/reference/functions"

New-MarkdownHelp -Module psake -OutputFolder $mdHelpPath -Force -Verbose:$VerbosePreference > $null

}

function UpdateMarkdownHelp {

[DependsOn('Init')]

[CmdletBinding()]

param()

'TODO'

}

function StageNuget {

[DependsOn('Build')]

[CmdletBinding()]

param()

$here = $PSScriptRoot

"Staging Nuget Files"

$dest = $outputNugetDir

if (Test-Path -Path $dest -PathType Container) {

Remove-Item -Path $dest -Recurse -Force

}

$destTools = Join-Path -Path $dest -ChildPath tools

Copy-Item -Recurse -Path "$here/build/nuget" -Destination $dest -Exclude 'nuget.exe'

Copy-Item -Recurse -Path "$outputModVerDir" -Destination "$destTools/psake"

@('README.md', 'license') | ForEach-Object {

Copy-Item -Path "$here/$_" -Destination $destTools

}

"Updating nuspec version"

$specPath = "$dest\psake.nuspec"

$spec = [xml](Get-Content -Raw $specPath)

$spec.package.metadata.version = $version

$spec.Save($specPath)

}

function PublishChocolatey {

[DependsOn('StageNuget')]

[CmdletBinding()]

param()

try {

Push-Location $outputNugetDir

choco pack

if ($null -eq $(choco apikey list -r)) {

throw "No Choco API key is set! Not publishing choco package."

}

choco push --source "'https://push.chocolatey.org/'"

} finally {

Pop-Location

}

}

function PublishNuget {

[DependsOn('StageNuget')]

[CmdletBinding()]

param()

"Building nuget package version [$version]"

try {

Push-Location $outputNugetDir

$nugetBin = Resolve-Path "$PSScriptRoot\build\nuget\NuGet.exe"

& $nugetBin pack "./psake.nuspec" -Verbosity quiet -Version $version -Properties NoWarn='NU5111,NU5125'

$nupkg = (Get-ChildItem "psake*.nupkg").Name

if ($null -eq $ENV:NUGET_API_KEY) {

throw 'Nuget API is not set! Not publishing.'

}

dotnet nuget push $nupkg --api-key $ENV:NUGET_API_KEY --source https://api.nuget.org/v3/index.json

} finally {

Pop-Location

}

}

function PublishPSGallery {

[DependsOn('Build')]

[CmdletBinding()]

param()

"Publishing version [$Version] to PSGallery.."

if ($null -eq $env:PSGALLERY_API_KEY) {

throw 'PSGallery API is not set! Not publishing.'

}

$publishParams = @{

Path = $outputModVerDir

Repository = 'PSGallery'

Verbose = $VerbosePreference

NuGetApiKey = $env:PSGALLERY_API_KEY

}

Publish-Module @publishParams

}

function ConvertFromLocalizationYaml {

[DependsOn('Init')]

[CmdletBinding()]

param()

$languages = Get-ChildItem -Path "$PSScriptRoot\l10n" -Filter '*.yml' -File

foreach ($lang in $languages) {

$yaml = Get-Content -Path $lang.FullName -Raw | ConvertFrom-Yaml

foreach ($locale in $yaml.Keys) {

Write-Verbose "Processing locale: $locale"

$localeDir = Join-Path -Path $sut -ChildPath $locale

if (-not (Test-Path -Path $localeDir)) {

New-Item -Path $localeDir -ItemType Directory > $null

}

$psd1 = Join-Path -Path $localeDir -ChildPath "Messages.psd1"

$content = [System.Text.StringBuilder]::new()

$warningMessage = "# This file is auto-generated from YAML localization files. Do not edit manually."

[void]$content.AppendLine($warningMessage)

[void]$content.AppendLine("ConvertFrom-StringData @'")

$sortedKeys = $yaml[$locale].Keys | Sort-Object

foreach ($key in $sortedKeys) {

Write-Verbose "Processing key: $key"

# We don't need to worry about escaping here, as the keys are simple strings

# and the values are already escaped by ConvertFrom-Yaml

$value = $yaml[$locale][$key]

[void]$content.AppendLine(" $key=$value")

}

[void]$content.AppendLine("'@")

Write-Verbose "Writing to $psd1"

Set-Content -Path $psd1 -Encoding UTF8 -Value $content.ToString()

# Due to a pwsh bug we need to keep a copy in the PSM1 file

if ($locale -eq 'en-US') {

$psm1 = Join-Path -Path $sut -ChildPath 'psake.psm1'

# Also copy the en-US messages to the psm1 file

$Tokens = $null

$Errors = $null

$ast = [System.Management.Automation.Language.Parser]::ParseFile(

$psm1,

[ref]$Tokens,

[ref]$Errors

)

# find the data block and replace it

$dataBlock = $ast.Find({ param($ast) $ast -is [System.Management.Automation.Language.DataStatementAst] }, $false)

# dataBlock.Extent will give us the range of the data block

if ($dataBlock) {

Write-Verbose "Updating data block in psake.psm1 with en-US messages"

# Remove the first line which is the comment

[void]$content.Remove(0, $warningMessage.Length + 1)

$dataBlockContent = $content.ToString()

$dataBlockExtent = $dataBlock.Body.Extent

# WARNING: Be careful with the offsets, as they are 0-based and the content is UTF8 encoded

$newContent = $ast.Extent.Text.Substring(0, $dataBlockExtent.StartOffset + 1) + $dataBlockContent + $ast.Extent.Text.Substring($dataBlockExtent.EndOffset - 1)

# Remove extra new line at the end

$newContent = $newContent.TrimEnd("`r`n")

Set-Content -Path $psm1 -Value $newContent -Encoding UTF8

} else {

Write-Warning "No data block found in psake.psm1 to update with en-US messages."

}

}

}

}

}

try {

Push-Location

Invoke-Step $Task

} catch {

throw $_

exit 1

} finally {

Pop-Location

}