Build.ps1

#requires -Version "4.0" -Module PackageManagement, Pester, Configuration
[CmdletBinding()]
param(
    # The step(s) to run. Defaults to "Clean", "Update", "Build", "Test", "Package"
    # You may also "Publish"
    # It's also acceptable to skip the "Clean" and particularly "Update" steps
    [ValidateSet("Clean", "Update", "Build", "Test", "Package", "Publish")]
    [string[]]$Step = @("Clean", "Update", "Build", "Test"),

    # The path to the module to build. Defaults to the folder this script is in.
    [Alias("PSPath")]
    [string]$Path = $PSScriptRoot,

    [string]$ModuleName = $(Split-Path $Path -Leaf),

    # The target framework for .net (for packages), with fallback versions
    # The default supports PS3:  "net40","net35","net20","net45"
    # To only support PS4, use:  "net45","net40","net35","net20"
    # To support PS2, you use:   "net35","net20"
    [string[]]$TargetFramework = @("net40","net35","net20","net45","netstandard2.0"),

    # The revision number (pulled from the environment in AppVeyor)
    [Nullable[int]]$RevisionNumber = ${Env:APPVEYOR_BUILD_NUMBER},

    [ValidateNotNullOrEmpty()]
    [String]$CodeCovToken = ${ENV:CODECOV_TOKEN},

    # The default language is your current UICulture
    [Globalization.CultureInfo]$DefaultLanguage = $((Get-Culture).Name)
)

$Script:TraceVerboseTimer = New-Object System.Diagnostics.Stopwatch
$Script:TraceVerboseTimer.Start()


$ErrorActionPreference = "Stop"
# Set-StrictMode -Version Latest

function init {
    #.Synopsis
    #   The init step always has to run.
    #   Calculate your paths and so-on here.
    [CmdletBinding()]
    param()

    # Calculate Paths
    # The output path is just a temporary output and logging location
    $Script:OutputPath = Join-Path $Path output
    $null = mkdir $OutputPath -Force

    # We expect the source for the module in a subdirectory called one of three things:
    $Script:SourcePath = "src", "source", ${ModuleName} | ForEach { Join-Path $Path $_ -Resolve -ErrorAction Ignore } | Select -First 1
    if(!$SourcePath) {
        Write-Warning "This Build script expects a 'Source' or '$ModuleName' folder to be alongside it."
        throw "Can't find module source folder."
    }

    $Script:ManifestPath = Join-Path $SourcePath "${ModuleName}.psd1" -Resolve -ErrorAction Ignore
    if(!$ManifestPath) {
        Write-Warning "This Build script expects a '${ModuleName}.psd1' in the '$SourcePath' folder."
        throw "Can't find module source files"
    }
    $Script:TestPath = "Tests", "Specs" | ForEach { Join-Path $Path $_ -Resolve -ErrorAction Ignore } | Select -First 1
    if(!$TestPath) {
        Write-Warning "This Build script expects a 'Tests' or 'Specs' folder to contain tests."
    }
    # Calculate Version here, because we need it for the release path
    [Version]$Script:Version = Get-Metadata $ManifestPath -PropertyName ModuleVersion

    # If the RevisionNumber is specified as ZERO, this is a release build ...
    # If the RevisionNumber is not specified, this is a dev box build
    # If the RevisionNumber is specified, we assume this is a CI build
    if($Script:RevisionNumber -ge 0) {
        # For CI builds we don't increment the build number
        $Script:Build = if($Version.Build -le 0) { 0 } else { $Version.Build }
    } else {
        # For dev builds, assume we're working on the NEXT release
        $Script:Build = if($Version.Build -le 0) { 1 } else { $Version.Build + 1}
    }

    if([string]::IsNullOrEmpty($RevisionNumber) -or $RevisionNumber -eq 0) {
        $Script:Version = New-Object Version $Version.Major, $Version.Minor, $Build
    } else {
        $Script:Version = New-Object Version $Version.Major, $Version.Minor, $Build, $RevisionNumber
    }

    # The release path is where the final module goes
    $Script:ReleasePath = Join-Path $Path $Version
    $Script:ReleaseManifest = Join-Path $ReleasePath "${ModuleName}.psd1"

}

function clean {
    #.Synopsis
    #   Clean output and old log
    [CmdletBinding()]
    param(
        # Also clean packages
        [Switch]$Packages
    )

    $DeleteMe = Join-Path $Env:Temp "Delete This Folder"

    while(Test-Path $DeleteMe -PathType Leaf) {
        $DeleteMe = $DeleteMe + "!"
    }

    if(Test-Path $DeleteMe -PathType Container) {
        Remove-Item $DeleteMe -Recurse -Force -ErrorAction SilentlyContinue
    }
    $DeleteMe = Join-Path $DeleteMe ([Guid]::NewGuid().Guid)
    $null = New-Item $DeleteMe -Type Directory -Force

    Trace-Message "OUTPUT Release Path: $ReleasePath"
    if(Test-Path $ReleasePath) {
        Trace-Message "       Clean up old build"
        Trace-Message "REMOVE $ReleasePath\"
        Push-Location $ReleasePath
        foreach($file in Get-ChildItem $ReleasePath -Recurse | Where-Object { !$_.PSIsContainer }) {
            $RelPath = Resolve-Path $file.FullName -Relative | Split-Path
            $Destination = Join-Path $DeleteMe $RelPath
            $Destination = (New-Item $Destination -Type Directory -Force).FullName
            Trace-Message "(re)move $RelPath to $Destination"
            Move-Item $file.FullName -Force -Destination $Destination
        }
        Pop-Location
        Remove-Item $ReleasePath -Force -Recurse
    }

    if (Test-Path $Path\packages) {
        Trace-Message "DELETE $Path\packages"
        # force reinstall by cleaning the old ones
        Remove-Item $Path\packages\ -Recurse -Force -ErrorAction Continue
    }
    if (Test-Path $OutputPath\packages\build.log) {
        Trace-Message "DELETE $OutputPath\build.log"
        Remove-Item $OutputPath\build.log -Recurse -Force -ErrorAction Continue
    }
}

function update {
    #.Synopsis
    #   Nuget restore and git submodule update
    #.Description
    #   This works like nuget package restore, but using PackageManagement
    #   The benefit of using PackageManagement is that you can support any provider and any source
    #   However, currently only the nuget providers supports a -Destination
    #   So for most cases, you could use nuget restore instead:
    #      nuget restore $(Join-Path $Path packages.config) -PackagesDirectory "$Path\packages" -ExcludeVersion -PackageSaveMode nuspec
    [CmdletBinding()]
    param(
        # Force reinstall
        [switch]$Force=$($Step -contains "Clean"),

        # Remove packages first
        [switch]$Clean
    )
    $ErrorActionPreference = "Stop"
    Set-StrictMode -Version Latest
    Trace-Message "UPDATE $ModuleName in $Path"

    # Nuget dependencies
    if(Test-Path (Join-Path $Path packages.config)) {
        if(!($Name = Get-PackageSource | ? Location -match 'https://www.nuget.org/api/v2' | % Name)) {
            Write-Warning "Adding NuGet package source"
            $Name = Register-PackageSource NuGet -Location 'https://www.nuget.org/api/v2' -ForceBootstrap -ProviderName NuGet | % Name
        }

        if($Force -and (Test-Path $Path\packages)) {
            # force reinstall by cleaning the old ones
            remove-item $Path\packages\ -Recurse -Force
        }
        $null = mkdir $Path\packages\ -Force

        # Remember, as of now, only nuget actually supports the -Destination flag
        foreach($Package in ([xml](gc .\packages.config)).packages.package) {
            Trace-Message "Installing $($Package.id) v$($Package.version) from $($Package.Source)"
            $install = Install-Package -Name $Package.id -RequiredVersion $Package.version -Source $Package.Source -Destination $Path\packages -Force:$Force -ErrorVariable failure
            if($failure) {
                throw "Failed to install $($package.id), see errors above."
            }
        }
    }

    # Make sure the modules we're dependent on are installed
    foreach($manifest in Get-ChildItem $Script:SourcePath -filter *.psd1 -Recurse) {
        foreach($Dependency in (Get-Module $manifest.FullName -ListAvailable -ErrorAction SilentlyContinue).RequiredModules) {
            if(!(Get-Module $Dependency.Name -ListAvailable -EA 0)) {
                Write-Warning "Installing $($Dependency.Name) in -Scope CurrentUser"
                Install-Module -Name $Dependency.Name -AllowClobber -Force -SkipPublisherCheck -Scope CurrentUser
            }
        }
    }
}

function build {
    [CmdletBinding()]
    param()
    Trace-Message "BUILDING: $ModuleName from $Path"
    # Copy NuGet dependencies
    $PackagesConfig = (Join-Path $Path packages.config)
    if(Test-Path $PackagesConfig) {
        Trace-Message "       Copying Packages"
        foreach($Package in ([xml](Get-Content $PackagesConfig)).packages.package) {
            $LibPath = "$ReleasePath\lib"
            $folder = Join-Path $Path "packages\$($Package.id)*"

            # The git NativeBinaries are special -- we need to copy all the binaries:
            if($Package.id -eq "LibGit2Sharp.NativeBinaries") {
                $targets = Join-Path $folder 'runtimes'
                $LibPath = Join-Path $LibPath "NativeBinaries"
            } else {
                # Check for each TargetFramework, in order of preference, fall back to using the lib folder
                $targets = ($TargetFramework -replace '^','lib\') + 'lib' | ForEach-Object { Join-Path $folder $_ }
            }

            $PackageSource = Get-Item $targets -ErrorAction SilentlyContinue | Select -First 1 -Expand FullName
            if(!$PackageSource) {
                throw "Could not find a lib folder for $($Package.id) from package. You may need to run Build -Step Update"
            }

            Trace-Message "robocopy $PackageSource $LibPath /E /NP /LOG+:'$OutputPath\build.log' /R:2 /W:15"
            $null = robocopy $PackageSource $LibPath /E /NP /LOG+:"$OutputPath\build.log" /R:2 /W:15
            if($LASTEXITCODE -gt 3) {
                throw "Failed to copy Package $($Package.id) (${LASTEXITCODE}), see build.log for details"
            }
        }
    }


    ## Copy PowerShell source Files (support for my new Public|Private folders, and the old simple copy way)
    # if the Source folder has "Public" and optionally "Private" in it, then the psm1 must be assembled:
    if(Test-Path (Join-Path $SourcePath Public) -Type Container){
        Trace-Message "       Collating Module Source"
        $RootModule = Get-Metadata -Path $ManifestPath -PropertyName RootModule -ErrorAction SilentlyContinue
        if(!$RootModule) {
            $RootModule = Get-Metadata -Path $ManifestPath -PropertyName ModuleToProcess -ErrorAction SilentlyContinue
            if(!$RootModule) {
                $RootModule = "${ModuleName}.psm1"
            }
        }
        $null = mkdir $ReleasePath -Force
        $ReleaseModule = Join-Path $ReleasePath ${RootModule}
        Trace-Message "       Setting content for $ReleaseModule"

        $FunctionsToExport = Join-Path $SourcePath Public\*.ps1 -Resolve |
            ForEach-Object { [System.IO.Path]::GetFileNameWithoutExtension($_) }

        Set-Content $ReleaseModule ((
            $(Get-Content -Raw $(Join-Path $SourcePath Private\*.ps1) -ErrorAction SilentlyContinue) +
            $(Get-Content -Raw $(Join-Path $SourcePath Public\*.ps1))) -join "`r`n`r`n`r`n") -Encoding UTF8

        # If there are any folders that aren't Public, Private, Tests, or Specs ...
        $OtherFolders = Get-ChildItem $SourcePath -Directory -Exclude Public, Private, Tests, Specs
        # Then we need to copy everything in them
        Copy-Item $OtherFolders -Recurse -Destination $ReleasePath

        # Finally, we need to copy any files in the Source directory
        Get-ChildItem $SourcePath -File |
            Where Name -ne $RootModule |
            Copy-Item -Destination $ReleasePath

        Update-Manifest $ReleaseManifest -Property FunctionsToExport -Value $FunctionsToExport
    } else {
        # Legacy modules just have "stuff" in the source folder and we need to copy all of it
        Trace-Message "       Copying Module Source"
        Trace-Message "COPY   $SourcePath\"
        $null = robocopy $SourcePath\  $ReleasePath /E /NP /LOG+:"$OutputPath\build.log" /R:2 /W:15
        if($LASTEXITCODE -ne 3 -AND $LASTEXITCODE -ne 1) {
            throw "Failed to copy Module (${LASTEXITCODE}), see build.log for details"
        }
    }

    # Copy the readme file as an about_ help
    $ReadMe = Join-Path $Path Readme.md
    if(Test-Path $ReadMe -PathType Leaf) {
        $LanguagePath = Join-Path $ReleasePath $DefaultLanguage
        $null = mkdir $LanguagePath -Force
        $about_module = Join-Path $LanguagePath "about_${ModuleName}.help.txt"
        if(!(Test-Path $about_module)) {
            Trace-Message "Turn readme into about_module"
            Copy-Item -LiteralPath $ReadMe -Destination $about_module
        }
    }

    ## Update the PSD1 Version:
    Trace-Message "       Update Module Version"
    Push-Location $ReleasePath
    $FileList = Get-ChildItem -Recurse -File | Resolve-Path -Relative
    Update-Metadata -Path $ReleaseManifest -PropertyName 'ModuleVersion' -Value $Version
    Update-Metadata -Path $ReleaseManifest -PropertyName 'FileList' -Value $FileList
    Pop-Location
    (Get-Module $ReleaseManifest -ListAvailable | Out-String -stream) -join "`n" | Trace-Message
}

function test {
    [CmdletBinding()]
    param(
        [Switch]$Quiet,

        [Switch]$ShowWip,

        [int]$FailLimit=${Env:ACCEPTABLE_FAILURE},

        [ValidateNotNullOrEmpty()]
        [String]$JobID = ${Env:APPVEYOR_JOB_ID}
    )

    if(!$TestPath) {
        Write-Warning "No tests folder found. Invoking Pester in root: $Path"
        $TestPath = $Path
    }

    Trace-Message "TESTING: $ModuleName with $TestPath"

    Trace-Message "TESTING $ModuleName v$Version" -Verbose:(!$Quiet)
    Remove-Module $ModuleName -ErrorAction SilentlyContinue

    $PesterOptions = @{
        OutputFormat = "NUnitXml"
        OutputFile = (Join-Path $OutputPath TestResults.xml)
    }
    if($Quiet) { $PesterOptions.Quiet = $Quiet }
    if(!$ShowWip){ $PesterOptions.ExcludeTag = @("wip") }

    Set-Content "$TestPath\.Do.Not.COMMIT.This.Steps.ps1" "Import-Module $ReleasePath\${ModuleName}.psd1 -Force"

    # Show the commands they would have to run to get these results:
    Write-Host "C:\PS> " -NoNewLine
    Write-Host Import-Module $ReleasePath\${ModuleName}.psd1 -Force

    if(Get-Command Invoke-Gherkin -ErrorAction SilentlyContinue) {
        Write-Host "C:\PS> " -NoNewLine
        Write-Host Invoke-Gherkin -Path $TestPath -CodeCoverage "$ReleasePath\*.psm1" -PassThru @PesterOptions
        $TestResults = Invoke-Gherkin -Path $TestPath -CodeCoverage "$ReleasePath\*.psm1" -PassThru @PesterOptions
    }

    # Write-Host "C:\PS> " -NoNewLine
    # Write-Host Invoke-Pester -Path $TestPath -CodeCoverage "$ReleasePath\*.psm1" -PassThru @PesterOptions
    # $TestResults += @(Invoke-Pester -Path $TestPath -CodeCoverage "$ReleasePath\*.psm1" -PassThru @PesterOptions)

    Remove-Module $ModuleName -ErrorAction SilentlyContinue
    Remove-Item "$TestPath\.Do.Not.COMMIT.This.Steps.ps1"

    $script:failedTestsCount = 0
    $script:passedTestsCount = 0

    if($TestResults -and $TestResults.CodeCoverage.NumberOfCommandsAnalyzed -gt 0)
    {
        $script:failedTestsCount += $TestResults.FailedCount
        $script:passedTestsCount += $TestResults.PassedCount
        $CodeCoverageTitle = 'Code Coverage {0:F1}%'  -f (100 * ($TestResults.CodeCoverage.NumberOfCommandsExecuted / $TestResults.CodeCoverage.NumberOfCommandsAnalyzed))

        # TODO: this file mapping does not account for the new Public|Private module source (and I don't know how to make it do so)
        # Map file paths, e.g.: \1.0 back to \src
        for($i=0; $i -lt $TestResults.CodeCoverage.HitCommands.Count; $i++) {
            $TestResults.CodeCoverage.HitCommands[$i].File = $TestResults.CodeCoverage.HitCommands[$i].File.Replace($ReleasePath, $SourcePath)
        }
        for($i=0; $i -lt $TestResults.CodeCoverage.MissedCommands.Count; $i++) {
            $TestResults.CodeCoverage.MissedCommands[$i].File = $TestResults.CodeCoverage.MissedCommands[$i].File.Replace($ReleasePath, $SourcePath)
        }

        if($TestResults.CodeCoverage.MissedCommands.Count -gt 0) {
            $TestResults.CodeCoverage.MissedCommands |
                ConvertTo-Html -Title $CodeCoverageTitle |
                Out-File (Join-Path $OutputPath "CodeCoverage-${Version}.html")
        }
        if(${CodeCovToken})
        {
            try {
                # TODO: https://github.com/PoshCode/PSGit/blob/dev/test/Send-CodeCov.ps1
                Trace-Message "Sending CI Code-Coverage Results" -Verbose:(!$Quiet)
                $response = &"$TestPath\Send-CodeCov" -CodeCoverage $TestResults.CodeCoverage -RepositoryRoot $Path -OutputPath $OutputPath -Token ${CodeCovToken}
                Trace-Message $response.message -Verbose:(!$Quiet)
            } catch {
                Write-Warning "Error sending code-coverage data to CodeCov $($response)"
            }
        }
    }

    # If we're on AppVeyor ....
    if(Get-Command Add-AppveyorCompilationMessage -ErrorAction SilentlyContinue) {

        Add-AppveyorCompilationMessage -Message ("{0} of {1} tests passed" -f @($TestResults.PassedScenarios).Count, (@($TestResults.PassedScenarios).Count + @($TestResults.FailedScenarios).Count)) -Category $(if(@($TestResults.FailedScenarios).Count -gt 0) { "Warning" } else { "Information"})

        Add-AppveyorCompilationMessage -Message ("{0:P} of code covered by tests" -f ($TestResults.CodeCoverage.NumberOfCommandsExecuted / $TestResults.CodeCoverage.NumberOfCommandsAnalyzed)) -Category $(if($TestResults.CodeCoverage.NumberOfCommandsExecuted -lt $TestResults.CodeCoverage.NumberOfCommandsAnalyzed) { "Warning" } else { "Information"})
    }

    if(${JobID}) {
        if(Test-Path $PesterOptions.OutputFile) {
            Trace-Message "Sending Test Results to AppVeyor backend" -Verbose:(!$Quiet)
            $wc = New-Object 'System.Net.WebClient'
            $response = $wc.UploadFile("https://ci.appveyor.com/api/testresults/nunit/${JobID}", $PesterOptions.OutputFile)
            if($response) {
                Trace-Message ([System.Text.Encoding]::ASCII.GetString($response)) -Verbose:(!$Quiet)
            }
        } else {
            Write-Warning "Couldn't find Test Output: $($PesterOptions.OutputFile)"
        }
    }

    if($FailedTestsCount -gt $FailLimit) {
        $exception = New-Object AggregateException "Failed Scenarios:`n`t`t'$($TestResults.FailedScenarios.Name -join "'`n`t`t'")'"
        $errorRecord = New-Object System.Management.Automation.ErrorRecord $exception, "FailedScenarios", "LimitsExceeded", $Results
        $PSCmdlet.ThrowTerminatingError($errorRecord)
    }
}

function package {
    [CmdletBinding()]
    param()

    Trace-Message "robocopy '$ReleasePath' '${OutputPath}\${ModuleName}' /MIR /NP "
    $null = robocopy $ReleasePath "${OutputPath}\${ModuleName}" /MIR /NP /LOG+:"$OutputPath\build.log"

    $zipFile = Join-Path $OutputPath "${ModuleName}-${Version}.zip"
    Add-Type -assemblyname System.IO.Compression.FileSystem
    Remove-Item $zipFile -ErrorAction SilentlyContinue
    Trace-Message "ZIP    $zipFile"
    [System.IO.Compression.ZipFile]::CreateFromDirectory((Join-Path $OutputPath $ModuleName), $zipFile)

    # You can add other artifacts here
    ls $OutputPath -File
}

function Trace-Message {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true)]
        [string]$Message,

        [switch]$AsWarning,

        [switch]$ResetTimer,

        [switch]$KillTimer,

        [Diagnostics.Stopwatch]$Stopwatch
    )
    begin {
        if($Stopwatch) {
            $Script:TraceTimer = $Stopwatch
            $Script:TraceTimer.Start()
        }
        if(!(Test-Path Variable:Script:TraceTimer)) {
            $Script:TraceTimer = New-Object System.Diagnostics.Stopwatch
            $Script:TraceTimer.Start()
        }
        if($ResetTimer)
        {
            $Script:TraceTimer.Restart()
        }
    }

    process {
        $Script = Split-Path $MyInvocation.ScriptName -Leaf
        $Command = (Get-PSCallStack)[1].Command
        if($Script -ne $Command) {
            $Message = "{0} - at {1} Line {2} ({4}) | {3}" -f $Message, $Script, $MyInvocation.ScriptLineNumber, $TraceTimer.Elapsed, $Command
        } else {
            $Message = "{0} - at {1} Line {2} | {3}" -f $Message, $Script, $MyInvocation.ScriptLineNumber, $TraceTimer.Elapsed
        }

        if($AsWarning) {
            Write-Warning $Message
        } else {
            Write-Verbose $Message
        }
    }

    end {
        if($KillTimer) {
            $Script:TraceTimer.Stop()
            $Script:TraceTimer = $null
        }
    }
}

# First call to Trace-Message, pass in our TraceTimer to make sure we time EVERYTHING.
Trace-Message "BUILDING: $ModuleName in $Path" -Stopwatch $TraceVerboseTimer

Push-Location $Path

init

foreach($s in $step){
    Trace-Message "Invoking Step: $s"
    &$s
}

Pop-Location
Trace-Message "FINISHED: $ModuleName in $Path" -KillTimer