New-Archive.ps1

Function New-Archive {
<#
.DESCRIPTION
Creates a ZIP archive.
#>
    [CmdletBinding(DefaultParameterSetName = 'ByParam')]
    Param(
        [Parameter(Mandatory, ParameterSetName = 'ByParam', Position = 0)]
        [ValidateScript({Test-Path -Path $_ -PathType Container})]
        [String]$Path,
        [Parameter(Mandatory, ParameterSetName = 'ByPipe', ValueFromPipeline)]
        [Object[]]$InputObject,
        [Parameter(Mandatory, ParameterSetName = 'ByParam', Position = 1)]
        [Parameter(Mandatory, ParameterSetName = 'ByPipe', Position = 0)]
        [ValidateScript({Test-Path -Path (Split-Path -Path $_ -Parent) -PathType Container})]
        [String]$ArchivePath,
        [Parameter(ParameterSetName = 'ByParam')]
        [String]$Filter = "*",
        [Parameter(ParameterSetName = 'ByParam')]
        [String[]]$Include = "",
        [Parameter(ParameterSetName = 'ByParam')]
        [String[]]$Exclude = "",
        [Parameter(ParameterSetName = 'ByParam')]
        [Switch]$Recurse,
        [Parameter(ParameterSetName = 'ByParam')]
        [Parameter(ParameterSetName = 'ByPipe')]
        [ArgumentCompleter({
            Add-Type -AssemblyName 'System.IO.Compression.FileSystem'
            [enum]::GetNames([System.IO.Compression.CompressionLevel])
        })]
        [ValidateScript({
            Add-Type -Assembly 'System.IO.Compression.FileSystem'
            $null -ne [System.IO.Compression.CompressionLevel]::$_
        })]
        [System.IO.Compression.CompressionLevel]$CompressionLevel = 'Optimal',
        [Parameter(ParameterSetName = 'ByParam')]
        [Parameter(ParameterSetName = 'ByPipe')]
        [Switch]$Force
    )

    begin {

        Function Get-RelativePath {
            Param(
                [Parameter(Mandatory)][String]$ParentPath,
                [Parameter(Mandatory, ValueFromPipeline)][String]$FullPath
            )
            process {
                Return $FullPath.Replace("$ParentPath\",$null)
            }
        }

        [String]$ArchiveName = Split-Path -Path $ArchivePath -Leaf
        [String]$ArchiveDir = Split-Path -Path $ArchivePath -Parent | Resolve-Path
        [String]$ArchiveFile = "$ArchiveDir\$ArchiveName"

        [bool]$ArchiveExists = Test-Path -Path $ArchiveFile -PathType Leaf

        If ($ArchiveExists -and -not $Force) {

            Write-Host "$(Split-Path -Path $ArchiveFile -Leaf) already exists. Overwrite existing archive? [Y/N]" -ForegroundColor Yellow -NoNewline

            While ($true) {

                [System.ConsoleKey]$Key = [System.Console]::ReadKey($true)

                If ($Key.Key -eq 'Y' -and $Key.Modifers -eq '0') {
                    Write-Host "$(($Key).Char)"
                    $Force = $true
                    Break
                }
                ElseIf ($Key.Key -eq 'N' -and $Key.Modifiers -eq '0') {
                    Write-Host "$(($Key).Char)"
                    return $false
                }
            }
        }

        Add-Type -AssemblyName 'System.IO.Compression','System.IO.Compression.FileSystem'

        If ($ArchiveExists) {
            Remove-Item $ArchiveFile -Force
        }

        [System.IO.Compression.ZipArchive]$Archive = [System.IO.Compression.ZipFile]::Open($ArchiveFile, [System.IO.Compression.ZipArchiveMode]::Create)

    }
    process {

        If ($PSCmdlet.ParameterSetName -eq "ByPipe") {

            [Object[]]$FSO += $InputObject

        }

    }
    end {

        If ($PSCmdlet.ParameterSetName -eq "ByParam") {
            [Object[]]$FSO = Get-ChildItem -Path $Path -Filter $Filter -Include $Include -Exclude $Exclude -Recurse:$Recurse
        }

        [String]$ArchiveSource = Split-Path -Path $FSO[0].FullName -Parent

        [String]$PrevPath = Get-Location | Select-Object -ExpandProperty Path
        Set-Location -Path $ArchiveSource

        [UInt32]$TotalFiles = ($FSO | Where-Object -FilterScript {$_.Attributes -notlike 'Directory'} | Measure-Object).Count
        [UInt32]$Count = 0
        [Byte]$Percent = [math]::Truncate($Count / $TotalFiles * 100)

        $ProgressParams = @{
            Activity            = "Compressing files..."
            Status              = "${Percent}% Complete"
            CurrentOperation    = "$ArchiveSource"
            PercentComplete     = $Percent
        }

        $FSO | ForEach-Object {

            [String]$RelativePath = $_.FullName | Get-RelativePath -ParentPath $ArchiveSource

            $ProgressParams.Status = "${Percent}% Complete"
            $ProgressParams.CurrentOperation = "[${ArchiveName}]\$RelativePath"

            Write-Progress @ProgressParams

            $Archive.CreateEntry(".\$RelativePath",$CompressionLevel) | Out-Null

            If ($_.Attributes -notlike 'Directory') {
                $Count++
                $Percent = ($Count / $TotalFiles * 100)
            }

            $ProgressParams.Status = "${Percent}% Complete"
            $ProgressParams.PercentComplete = $Percent

            Write-Progress @ProgressParams
        }


        $ProgressParams.Status = "100% Complete"
        $ProgressParams.CurrentOperation = $null
        $ProgressParams.PercentComplete = 100

        Write-Progress @ProgressParams

        $Archive.Dispose()

        Write-Progress @ProgressParams -Completed

        Set-Location -Path $PrevPath
    }
}