Unpacking Software Livestream

Join our monthly Unpacking Software livestream to hear about the latest news, chat and opinion on packaging, software deployment and lifecycle management!

Learn More
Chocolatey Product Spotlight

Join the Chocolatey Team on our regular monthly stream where we put a spotlight on the most recent Chocolatey product releases. You'll have a chance to have your questions answered in a live Ask Me Anything format.

Learn More
Chocolatey Coding Livestream

Join us for the Chocolatey Coding Livestream, where members of our team dive into the heart of open source development by coding live on various Chocolatey projects. Tune in to witness real-time coding, ask questions, and gain insights into the world of package management. Don't miss this opportunity to engage with our team and contribute to the future of Chocolatey!

Learn More
Calling All Chocolatiers! Whipping Up Windows Automation with Chocolatey Central Management

Webinar from
Wednesday, 17 January 2024

We are delighted to announce the release of Chocolatey Central Management v0.12.0, featuring seamless Deployment Plan creation, time-saving duplications, insightful Group Details, an upgraded Dashboard, bug fixes, user interface polishing, and refined documentation. As an added bonus we'll have members of our Solutions Engineering team on-hand to dive into some interesting ways you can leverage the new features available!

Watch On-Demand
Chocolatey Community Coffee Break

Join the Chocolatey Team as we discuss all things Community, what we do, how you can get involved and answer your Chocolatey questions.

Watch The Replays
Chocolatey and Intune Overview

Webinar Replay from
Wednesday, 30 March 2022

At Chocolatey Software we strive for simple, and teaching others. Let us teach you just how simple it could be to keep your 3rd party applications updated across your devices, all with Intune!

Watch On-Demand
Chocolatey For Business. In Azure. In One Click.

Livestream from
Thursday, 9 June 2022

Join James and Josh to show you how you can get the Chocolatey For Business recommended infrastructure and workflow, created, in Azure, in around 20 minutes.

Watch On-Demand
The Future of Chocolatey CLI

Livestream from
Thursday, 04 August 2022

Join Paul and Gary to hear more about the plans for the Chocolatey CLI in the not so distant future. We'll talk about some cool new features, long term asks from Customers and Community and how you can get involved!

Watch On-Demand
Hacktoberfest Tuesdays 2022

Livestreams from
October 2022

For Hacktoberfest, Chocolatey ran a livestream every Tuesday! Re-watch Cory, James, Gary, and Rain as they share knowledge on how to contribute to open-source projects such as Chocolatey CLI.

Watch On-Demand

Downloads:

768,444

Downloads of v 3.10.2.0:

76,584

Last Update:

18 Nov 2023

Package Maintainer(s):

Software Author(s):

  • Cabal Team

Tags:

cabal ghc haskell

Cabal

  • 1
  • 2
  • 3

3.10.2.0 | Updated: 18 Nov 2023

Downloads:

768,444

Downloads of v 3.10.2.0:

76,584

Maintainer(s):

Software Author(s):

  • Cabal Team

Tags:

cabal ghc haskell

Cabal 3.10.2.0

Legal Disclaimer: Neither this package nor Chocolatey Software, Inc. are affiliated with or endorsed by Cabal Team. The inclusion of Cabal Team trademark(s), if any, upon this webpage is solely to identify Cabal Team goods or services and not for commercial purposes.

  • 1
  • 2
  • 3

All Checks are Passing

3 Passing Tests

Validation Testing Passed

Verification Testing Passed

Details

Scan Testing Successful:

No detections found in any package files

Details
Learn More

Deployment Method: Individual Install, Upgrade, & Uninstall

To install Cabal, run the following command from the command line or from PowerShell:

>

To upgrade Cabal, run the following command from the command line or from PowerShell:

>

To uninstall Cabal, run the following command from the command line or from PowerShell:

>

Deployment Method:

NOTE

This applies to both open source and commercial editions of Chocolatey.

1. Enter Your Internal Repository Url

(this should look similar to https://community.chocolatey.org/api/v2/)

2. Setup Your Environment

1. Ensure you are set for organizational deployment

Please see the organizational deployment guide

2. Get the package into your environment

  • Open Source or Commercial:
    • Proxy Repository - Create a proxy nuget repository on Nexus, Artifactory Pro, or a proxy Chocolatey repository on ProGet. Point your upstream to https://community.chocolatey.org/api/v2/. Packages cache on first access automatically. Make sure your choco clients are using your proxy repository as a source and NOT the default community repository. See source command for more information.
    • You can also just download the package and push it to a repository Download

3. Copy Your Script

choco upgrade cabal -y --source="'INTERNAL REPO URL'" [other options]

See options you can pass to upgrade.

See best practices for scripting.

Add this to a PowerShell script or use a Batch script with tools and in places where you are calling directly to Chocolatey. If you are integrating, keep in mind enhanced exit codes.

If you do use a PowerShell script, use the following to ensure bad exit codes are shown as failures:


choco upgrade cabal -y --source="'INTERNAL REPO URL'" 
$exitCode = $LASTEXITCODE

Write-Verbose "Exit code was $exitCode"
$validExitCodes = @(0, 1605, 1614, 1641, 3010)
if ($validExitCodes -contains $exitCode) {
  Exit 0
}

Exit $exitCode


- name: Install cabal
  win_chocolatey:
    name: cabal
    version: '3.10.2.0'
    source: INTERNAL REPO URL
    state: present

See docs at https://docs.ansible.com/ansible/latest/modules/win_chocolatey_module.html.


chocolatey_package 'cabal' do
  action    :install
  source   'INTERNAL REPO URL'
  version  '3.10.2.0'
end

See docs at https://docs.chef.io/resource_chocolatey_package.html.


cChocoPackageInstaller cabal
{
    Name     = "cabal"
    Version  = "3.10.2.0"
    Source   = "INTERNAL REPO URL"
}

Requires cChoco DSC Resource. See docs at https://github.com/chocolatey/cChoco.


package { 'cabal':
  ensure   => '3.10.2.0',
  provider => 'chocolatey',
  source   => 'INTERNAL REPO URL',
}

Requires Puppet Chocolatey Provider module. See docs at https://forge.puppet.com/puppetlabs/chocolatey.

4. If applicable - Chocolatey configuration/installation

See infrastructure management matrix for Chocolatey configuration elements and examples.

Package Approved

This package was approved as a trusted package on 02 Dec 2024.

Description

The 'cabal.exe' command-line program simplifies the process of managing Haskell software by automating the fetching, configuration, compilation and installation of Haskell libraries and programs.

Cabal is a system for building and packaging Haskell libraries and programs. It defines a common interface for package authors and distributors to easily build their applications in a portable way. Cabal is part of a larger infrastructure for distributing, organizing, and cataloging Haskell libraries and programs.

Specifically, the Cabal describes what a Haskell package is, how these packages interact with the language, and what Haskell implementations must to do to support packages. The Cabal also specifies some infrastructure (code) that makes it easy for tool authors to build and distribute conforming packages.

The Cabal is only one contribution to the larger goal. In particular, the Cabal says nothing about more global issues such as how authors decide where in the module name space their library should live; how users can find a package they want; how orphan packages find new owners; and so on.

tools\chocolateyInstall.ps1 
$version     = '3.10.2.0'
$packageName = 'cabal'
$url         = 'https://downloads.haskell.org/cabal/cabal-install-3.2.0.0/cabal-install-3.2.0.0-i386-unknown-mingw32.zip'
$url64       = 'https://downloads.haskell.org/cabal/cabal-install-3.10.2.0/cabal-install-3.10.2.0-x86_64-windows.zip'
$binRoot         = $(Split-Path -parent $MyInvocation.MyCommand.Definition)
$packageFullName = Join-Path $binRoot ($packageName + '-' + $version)
$is64 = (Get-OSArchitectureWidth 64)  -and $env:chocolateyForceX86 -ne 'true'
$is32 = (Get-OSArchitectureWidth 32)  -or $env:chocolateyForceX86 -eq 'true'

if($is32)
  {
      Write-Host "#     # ####### ####### ###  #####  #######"
      Write-Host "##    # #     #    #     #  #     # #      "
      Write-Host "# #   # #     #    #     #  #       #      "
      Write-Host "#  #  # #     #    #     #  #       #####  "
      Write-Host "#   # # #     #    #     #  #       #      "
      Write-Host "#    ## #     #    #     #  #     # #      "
      Write-Host "#     # #######    #    ###  #####  #######"
      Write-Host ""
      Write-Host " 32 bit binary for Windows is not available."
      Write-Host "cabal 3.2.0.0 will be installed instead."
      Write-Host ""
      # rewrite the version to 3.2.0.0 so installer works
      $version = '3.2.0.0'
  }

Install-ChocolateyZipPackage `
  -PackageName $packageName `
  -UnzipLocation $packageFullName `
  -Url $url -ChecksumType sha256 -Checksum 01e14a9c4ec96452087b5cc90157693bbc4e0045b9c11e48f5f324b7977d837b `
  -Url64bit $url64 -ChecksumType64 sha256 -Checksum64 b09e335b2ebeafa1db5e1e5614e3e10fb37da230a36865d76646ab27b2f3f46b

$cabal = Join-Path $packageFullName "cabal.exe"
# Simplified version of Install-ChocolateyPath that prepends instead of
# Appends to a path.  We use this in certain cases when we need to Override an
# existing path entry.  Such as on AppVeyor which adds both cygwin and msys2
# on PATH.
function Install-AppVeyorPath {
param(
  [parameter(Mandatory=$true, Position=0)][string] $pathToInstall
)

  Write-FunctionCallLogMessage -Invocation $MyInvocation -Parameters $PSBoundParameters
  ## Called from chocolateysetup.psm1 - wrap any Write-Host in try/catch

  $pathType = [System.EnvironmentVariableTarget]::Machine

  # get the PATH variable
  Update-SessionEnvironment
  $envPath = $env:PATH
  if (!$envPath.ToLower().Contains($pathToInstall.ToLower()))
  {
    try {
      Write-Host "PATH environment variable does not have $pathToInstall in it. Adding..."
    } catch {
      Write-Verbose "PATH environment variable does not have $pathToInstall in it. Adding..."
    }

    $actualPath = Get-EnvironmentVariable -Name 'Path' -Scope $pathType -PreserveVariables

    $statementTerminator = ";"
    if (!$pathToInstall.EndsWith($statementTerminator)) {$pathToInstall = $pathToInstall + $statementTerminator}
    $actualPath = $pathToInstall + $actualPath

    Set-EnvironmentVariable -Name 'Path' -Value $actualPath -Scope $pathType

    # add it to the local path as well so users will be off and running
    $envPSPath = $env:PATH
    $env:Path = $pathToInstall + $envPSPath
  }
}

# uninstall a path entry from AppVeyor
function UnInstall-AppVeyorPath {
  param(
    [parameter(Mandatory=$true, Position=0)][string] $pathToRemove
  )

    Write-FunctionCallLogMessage -Invocation $MyInvocation -Parameters $PSBoundParameters
    ## Called from chocolateysetup.psm1 - wrap any Write-Host in try/catch

    $pathType = [System.EnvironmentVariableTarget]::Machine

    # get the PATH variable
    Update-SessionEnvironment
    $envPath = $env:PATH
    if ($envPath.ToLower().Contains($pathToRemove.ToLower()))
    {
      try {
        Write-Host "PATH environment variable contains $pathToRemove in it. Removing..."
      } catch {
        Write-Verbose "PATH environment variable contains $pathToRemove in it. Removing..."
      }

      $statementTerminator = ";"
      $actualPath = Get-EnvironmentVariable -Name 'Path' -Scope $pathType -PreserveVariables
      $actualPath = ($path.Split($statementTerminator) | Where-Object { $_ -ne $pathToRemove }) -join $statementTerminator

      Set-EnvironmentVariable -Name 'Path' -Value $actualPath -Scope $pathType

      # Remove it from the local path as well so users will be off and running
      $env:Path = $actualPath
    }
  }


function Find-Entry {
    param( [string] $app )
    Get-Command -ErrorAction SilentlyContinue $app `
      | Select-Object -first 1 `
      | ForEach-Object { Split-Path $_.Path -Parent }
}

Function Execute-Command {
  param( [string] $commandTitle
       , [string] $commandPath
       , [string] $commandArguments
       )
  Try {
    $pinfo = New-Object System.Diagnostics.ProcessStartInfo
    $pinfo.FileName = $commandPath
    $pinfo.RedirectStandardError = $true
    $pinfo.RedirectStandardOutput = $true
    $pinfo.UseShellExecute = $false
    $pinfo.Arguments = $commandArguments
    $pinfo.WindowStyle = [Diagnostics.ProcessWindowStyle]::Hidden
    $pinfo.CreateNoWindow = $true
    $p = New-Object System.Diagnostics.Process
    $p.StartInfo = $pinfo
    $p.Start() | Out-Null
    [pscustomobject]@{
        commandTitle = $commandTitle
        stdout = $p.StandardOutput.ReadToEnd()
        stderr = $p.StandardError.ReadToEnd()
        ExitCode = $p.ExitCode
    }
    $p.WaitForExit()
  }
  Catch {
     exit
  }
}

function Detect-GHC-Versions {
  return Get-ChildItem "C:\ghc\ghc-*\bin" -ErrorAction SilentlyContinue `
    | Sort-Object CreationTime -Descending `
    | ForEach-Object { $_.ToString() }
}

function Find-MSYS2 {
  param()

  # See if the user has msys2 already installed.
  $msys2 = Find-Entry "msys2_shell.cmd"
  if (($null -eq $msys2) -or ($msys2 -eq "")) {
    $msys2 = Find-Entry "mingw*_shell.bat"
  }

  $dir_name = if ($is64) { 'msys64' } else { 'msys32' }
  # Detect AppVeyor installs
  if (($null -ne $Env:APPVEYOR) -and ("" -ne $Env:APPVEYOR)) {
    Write-Host "AppVeyor detected. Using AppVeyor default paths."
    $msys2 = Join-Path $Env:SystemDrive $dir_name
  }

  # Check for standalone msys2 installs
  if (($null -eq $msys2) -or ($msys2 -eq "")) {
    $tmp = Join-Path $Env:SystemDrive $dir_name
    if (Test-Path $tmp -PathType Container) {
      Write-Host "Standalone msys2 detected. Using default paths."
      $msys2 = $tmp
    }
  }

  if (($null -eq $msys2) -or ($msys2 -eq "")) {
    # msys2 was not found already installed, assume user will install
    # it in the default directory, so create the expected default msys2
    # installation path.
    $msys2    = "{0}\{1}" -f (Get-ToolsLocation), $dir_name
  }

  Write-Debug "Msys2 directory: ${msys2}"
  return $msys2
}

function ReadCabal-Config {
  param( [string] $key )

  $prog = "$cabal"
  $cmd  = "user-config diff -a ${key}:"

  $proc = Execute-Command "Reading cabal config key '${key}'." $prog $cmd

  if ($proc.ExitCode -ne 0) {
    Write-Debug $proc.stdout
    Write-Debug $proc.stderr
    Write-Host "Could not read cabal configuration key '${key}'."
  }

  $option = [System.StringSplitOptions]::RemoveEmptyEntries
  $procout = $proc.stdout.Split([Environment]::NewLine) | Select-String "- ${key}" | Select-Object -First 1
  if (!$procout) {
    Write-Debug "No Cabal config for ${key}"
    return {@()}.Invoke()
  } else {
    $value = $procout.ToString().Split(@(':'), 2, $option)[1].ToString()
    $value = $value.Split([Environment]::NewLine)[0].Trim()
    Write-Debug "Read Cabal config ${key}: ${value}"
    return {$value.Replace('"','').Split(@(','), $option)}.Invoke()
  }
}

function UpdateCabal-Config {
  param( [string] $key
       , [string[]] $values
       )

  if ((!$values) -or ($values.Count -eq 0)) {
    $values = ""
  } else {
    #$value = '"' + [String]::Join("`",`"", $values) + '"'
    $value = [String]::Join(",", $values)
  }
  $prog = "$cabal"
  $cmd  = "user-config update -a `"${key}: $value`""

  $proc = Execute-Command "Update cabal config key '${key}'." $prog $cmd

  if ($proc.ExitCode -ne 0) {
    Write-Error $proc.stdout
    Write-Error $proc.stderr
    throw ("Could not update cabal configuration key '${key}'.")
  }

  Write-Debug "Wrote Cabal config ${key}: ${value}"
}

function UpdateCabal-Config-Raw {
  param( [string] $value
       )

  $prog = "$cabal"
  $cmd  = "user-config update $value"

  $proc = Execute-Command "Update cabal config key '${value}'." $prog $cmd

  if ($proc.ExitCode -ne 0) {
    Write-Error $proc.stdout
    Write-Error $proc.stderr
    throw ("Could not update cabal configuration key '${value}'.")
  }

  Write-Debug "Wrote Cabal config ${value}"
}

function Configure-Cabal {
  param()

  $ErrorActionPreference = 'Stop'
  $msys2_path   = Find-MSYS2

  # Initialize cabal
  $prog_path    = ReadCabal-Config "extra-prog-path"
  $lib_dirs     = ReadCabal-Config "extra-lib-dirs"
  $include_dirs = ReadCabal-Config "extra-include-dirs"
  $method       = ReadCabal-Config "install-method"
  $native_path  = if ($is64) { 'mingw64' } else { 'mingw32' }
  $native_path  = Join-Path $msys2_path $native_path
  $msys_lib_dir = Join-Path $native_path "lib"

  # Build new binary paths
  $native_bin     = Join-Path $native_path "bin"
  $new_prog_paths = @()
  $new_prog_paths += $native_bin
  $new_prog_paths += $prog_path
  $new_prog_paths += Join-Path (Join-Path $Env:APPDATA "cabal") "bin"
  $new_prog_paths += Join-Path (Join-Path $msys2_path "usr") "bin"
  $new_prog_paths = $new_prog_paths | Select-Object -Unique

  # Build new library paths

  # If the directory doesn't exist, we can't add it to prevent GHC from throwing
  # an error when the linker tries to add the dir.
  if (Test-Path $msys_lib_dir -PathType Container)
    {
      $new_lib_dirs = @($msys_lib_dir)
    }
  else
    {
      $new_lib_dirs = @()
    }
  $new_lib_dirs += $lib_dirs
  $new_lib_dirs = $new_lib_dirs | Select-Object -Unique

  # Build new include paths
  $new_include_dirs = @(Join-Path $native_path "include")
  $new_include_dirs += $include_dirs
  $new_include_dirs = $new_include_dirs | Select-Object -Unique

  # Set install method if no default is set
  if ($method -ne "copy" -and $method -ne "symlink" -and $method -ne "auto")
    {
      UpdateCabal-Config "install-method"     "copy"
    }

  UpdateCabal-Config "extra-prog-path"    $new_prog_paths
  UpdateCabal-Config "extra-lib-dirs"     $new_lib_dirs
  UpdateCabal-Config "extra-include-dirs" $new_include_dirs

  Write-Host "Updated cabal configuration."

  $cabal_path = Join-Path (Join-Path "$Env:APPDATA" "cabal") "bin"
  Install-ChocolateyPath "$cabal_path"

  # Add a PATH to pkg-config location if exists
  $pkg_config = Join-Path $native_bin "pkg-config.exe"
  if (Test-Path $pkg_config)
    {
      UpdateCabal-Config-Raw `
        "-a `"program-locations`" -a `" pkg-config-location: $pkg_config`""
    }

  # If running on Github actions, configure the package to pick things up
  if (($null -ne $Env:GITHUB_ACTIONS) -and ("" -ne $Env:GITHUB_ACTIONS)) {
    # Update the path on github actions as without so it won't be able to find
    # cabal.
    echo "$cabal_path" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append

    # We probably don't need this since choco itself is already on the PATH
    # But it won't hurt to make sure.
    $choco_bin = Join-Path $env:ChocolateyInstall "bin"
    echo "$choco_bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append

    # New GHC Packages will add themselves to the PATH, but older ones don't.
    # So let's find which one the user installed and add them to the pathh.
    $files = get-childitem $binRoot -include ghc.exe -recurse

    foreach ($file in $files) {
      $fileDir = Split-Path "$file"
      echo "$fileDir" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
    }

    # Also set a global SR.
    UpdateCabal-Config "store-dir" "$($env:SystemDrive)\SR"
  }

  # If running on Appveyor, configure the package to pick things up
  if (($null -ne $Env:APPVEYOR) -and ("" -ne $Env:APPVEYOR)) {
    Write-Host "Configuring AppVeyor PATH."
    # We need to fix up some paths for AppVeyor
    $ghcpaths = Detect-GHC-Versions
    ForEach ($path in $ghcpaths) { Install-ChocolateyPath $path }

    # Remove the global /usr/bin that's before the local one.
    UnInstall-AppVeyorPath (Join-Path (Join-Path "${msys2_path}" "usr") "bin")

    # Override msys2 git with git for Windows
    Install-AppVeyorPath "$($env:SystemDrive)\Program Files\Git\cmd"
    Install-AppVeyorPath "$($env:SystemDrive)\Program Files\Git\mingw64\bin"

    # I'm not a fan of doing this, but we need auto-reconf available.
    # Add the /usr/bin path first so it appears last in the list
    Install-AppVeyorPath (Join-Path (Join-Path "${msys2_path}" "usr") "bin")
    Install-AppVeyorPath (Join-Path (Join-Path "${msys2_path}" "mingw64") "bin")

    # Also set a global SR.
    UpdateCabal-Config "store-dir" "$($env:SystemDrive)\SR"
  }
}

function Find-Bash {
  param()
  $ErrorActionPreference = 'Stop'
  $msys2_path = Find-MSYS2
  $bin        = Join-Path (Join-Path $msys2_path "usr") "bin"
  $bash       = Join-Path $bin "bash.exe"
  return $bash
}

function Fudge-Config-Cabal {
  param()

  $ErrorActionPreference = 'Stop'

  Write-Host "Finding cabal config file..."
  $prog = "$cabal"
  $cmd  = "user-config init"

  $proc = Execute-Command "Detecting cabal config file location." $prog $cmd

  if ($proc.ExitCode -ne 0) {
    $ln = $proc.stderr.Split([Environment]::NewLine) | Select -First 1
    $skip = "cabal.exe: ".Length + 7
    $conf = $ln.Substring($skip, $ln.Length - $skip).Split(' ')[0]

    Write-Host "Detected config file: '${conf}'."
    $content = Get-Content -Path $conf -Raw
    # replace the broken unix line
    $content = $content -replace 'nix: ', '-- nix: '

    Set-Content -Path $conf -Value $content

    Write-Host "Forcibly correct backwards incompatible cabal configurations."
  } else {
    Write-Host "No cabal file hacks needed. Left config alone."
  }
}


# Now execute cabal configuration updates
Configure-Cabal
Fudge-Config-Cabal
$bash = Find-Bash
$prefix = if ($is64) { 'x86_64' } else { 'i686' }
Install-ChocolateyEnvironmentVariable "_MSYS2_BASH" "$bash"
Install-ChocolateyEnvironmentVariable "_MSYS2_PREFIX" "$prefix"
$psFile = Join-Path $(Split-Path -Parent $MyInvocation.MyCommand.Definition) "mingw64-pkg.ps1"
Install-ChocolateyPowershellCommand -PackageName '${packageName}.powershell' -PSFileFullPath $psFile
tools\chocolateyBeforeModify.ps1 
$version     = '3.10.2.0'
$packageName = 'cabal'
$url         = 'https://downloads.haskell.org/cabal/cabal-install-3.2.0.0/cabal-install-3.2.0.0-i386-unknown-mingw32.zip'
$url64       = 'https://downloads.haskell.org/cabal/cabal-install-3.10.2.0/cabal-install-3.10.2.0-x86_64-windows.zip'

$binRoot         = $(Split-Path -parent $MyInvocation.MyCommand.Definition)
$packageFullName = Join-Path $binRoot ($packageName + '-' + $version)
$is64 = (Get-OSArchitectureWidth 64)  -and $env:chocolateyForceX86 -ne 'true'

$cabal = Join-Path $packageFullName "cabal.exe"
function Find-Entry {
    param( [string] $app )
    Get-Command -ErrorAction SilentlyContinue $app `
      | Select-Object -first 1 `
      | ForEach-Object { Split-Path $_.Path -Parent }
}

Function Execute-Command {
  param( [string] $commandTitle
       , [string] $commandPath
       , [string] $commandArguments
       )
  Try {
    $pinfo = New-Object System.Diagnostics.ProcessStartInfo
    $pinfo.FileName = $commandPath
    $pinfo.RedirectStandardError = $true
    $pinfo.RedirectStandardOutput = $true
    $pinfo.UseShellExecute = $false
    $pinfo.Arguments = $commandArguments
    $pinfo.WindowStyle = [Diagnostics.ProcessWindowStyle]::Hidden
    $pinfo.CreateNoWindow = $true
    $p = New-Object System.Diagnostics.Process
    $p.StartInfo = $pinfo
    $p.Start() | Out-Null
    [pscustomobject]@{
        commandTitle = $commandTitle
        stdout = $p.StandardOutput.ReadToEnd()
        stderr = $p.StandardError.ReadToEnd()
        ExitCode = $p.ExitCode
    }
    $p.WaitForExit()
  }
  Catch {
     exit
  }
}

function Find-MSYS2 {
  param()

  # See if the user has msys2 already installed.
  $msys2 = Find-Entry "msys2_shell.cmd"
  if (($null -eq $msys2) -or ($msys2 -eq "")) {
    $msys2 = Find-Entry "mingw*_shell.bat"
  }

  $dir_name = if ($is64) { 'msys64' } else { 'msys32' }

  # Check for standalone msys2 installs
  if (($null -eq $msys2) -or ($msys2 -eq "")) {
    $tmp = Join-Path $Env:SystemDrive $dir_name
    if (Test-Path $tmp -PathType Container) {
      Write-Host "Standalone msys2 detected. Using default paths."
      $msys2 = $tmp
    }
  }

  if (($null -eq $msys2) -or ($msys2 -eq "")) {
    # msys2 was not found already installed, assume user will install
    # it in the default directory, so create the expected default msys2
    # installation path.
    $msys2    = "{0}\\{1}" -f (Get-ToolsLocation), $dir_name
  }

  Write-Debug "Msys2 directory: ${msys2}"
  return $msys2
}

function ReadCabal-Config {
  param( [string] $key )

  $prog = "$cabal"
  $cmd  = "user-config diff -a ${key}:"

  $proc = Execute-Command "Reading cabal config key '${key}'." $prog $cmd

  if ($proc.ExitCode -ne 0) {
    Write-Error $proc.stdout
    Write-Error $proc.stderr
    throw ("Could not read cabal configuration key '${key}'.")
  }

  $option = [System.StringSplitOptions]::RemoveEmptyEntries
  $procout = $proc.stdout.Split([Environment]::NewLine) | Select-String "- ${key}" | Select-Object -First 1
  if (!$procout) {
    Write-Debug "No Cabal config for ${key}"
    return {@()}.Invoke()
  } else {
    $value = $procout.ToString().Split(@(':'), 2, $option)[1].ToString()
    $value = $value.Split([Environment]::NewLine)[0].Trim()
    Write-Debug "Read Cabal config ${key}: ${value}"
    return {$value.Replace('"','').Split(@(','), $option)}.Invoke()
  }
}

function UpdateCabal-Config {
  param( [string] $key
       , [string[]] $values
       )

  if ((!$values) -or ($values.Count -eq 0)) {
    $values = ""
  } else {
    #$value = '"' + [String]::Join("`",`"", $values) + '"'
    $value = [String]::Join(",", $values)
  }
  $prog = "$cabal"
  $cmd  = "user-config update -a `"${key}: $value`""

  $proc = Execute-Command "Update cabal config key '${key}'." $prog $cmd

  if ($proc.ExitCode -ne 0) {
    Write-Error $proc.stdout
    Write-Error $proc.stderr
    throw ("Could not update cabal configuration key '${key}'.")
  }

  Write-Debug "Wrote Cabal config ${key}: ${value}"
}

function Restore-Config-Cabal {
  param()

  $ErrorActionPreference = 'Stop'
  $msys2_path   = Find-MSYS2
  $prog_path    = ReadCabal-Config "extra-prog-path"
  $lib_dirs     = ReadCabal-Config "extra-lib-dirs"
  $include_dirs = ReadCabal-Config "extra-include-dirs"

  $native_path = if ($is64) { 'mingw64' } else { 'mingw32' }
  $native_path = Join-Path $msys2_path $native_path
  $msys_lib_dir = Join-Path $native_path "lib"

  # Build new binary paths
  $native_bin     = Join-Path $native_path "bin"
  $new_prog_paths = {$prog_path}.Invoke()
  $new_prog_paths.Remove((Join-Path (Join-Path $msys2_path "usr") "bin")) | Out-Null
  $new_prog_paths.Remove(($native_bin)) | Out-Null
  $new_prog_paths = $new_prog_paths | Select-Object -Unique

  # Build new library paths
  $new_lib_dirs = {$lib_dirs}.Invoke()
  $new_lib_dirs.Remove((Join-Path $native_path "lib")) | Out-Null
  $new_lib_dirs = $new_lib_dirs | Select-Object -Unique

  # Build new include paths
  $new_include_dirs = {$include_dirs}.Invoke()
  $new_include_dirs.Remove((Join-Path $native_path "include")) | Out-Null
  $new_include_dirs = $new_include_dirs | Select-Object -Unique

  UpdateCabal-Config "extra-prog-path"    $new_prog_paths
  UpdateCabal-Config "extra-lib-dirs"     $new_lib_dirs
  UpdateCabal-Config "extra-include-dirs" $new_include_dirs

  Write-Host "Restored cabal configuration."
}

# Now execute cabal configuration updates
Restore-Config-Cabal
Uninstall-ChocolateyEnvironmentVariable -VariableName '_MSYS2_BASH'
Uninstall-ChocolateyEnvironmentVariable -VariableName '_MSYS2_PREFIX'
# Cleanup the batch file we created
Get-Command "mingw64-pkg.bat" -ErrorAction SilentlyContinue `
  | ForEach-Object { Remove-Item -Force $_ -ErrorAction SilentlyContinue }
tools\mingw64-pkg.ps1 
<#
.SYNOPSIS
    Install a Mingw-w64 native package such that cabal and ghc will recognize them.
.DESCRIPTION
    This CmdLet makes it easier to install native Mingw-w64 packages into MSYS2 such
    that cabal-install and GHC can use them without any other configuration required.

    This will not allow installation of MSYS2 packages.  Your global namespace will
    not be poluted by the use of this CmdLet.
.PARAMETER Action
    The action to perform. Must be one of install, uninstall, update or shell.

    - install: install a new native package
    - uninstall: remove native package
    - update: sync the repositories, will not upgrade any packages.
    - shell: open a bash shell
.PARAMETER Package
    The name of the Mingw64 package to install into the msys2 environment.
.PARAMETER NoConfirm
    Indicates whether or not an interactive prompt should be used to confirm before
    action is carried out.
.EXAMPLE
    C:\PS> mingw-pkg install gtk2
.NOTES
    Author: Tamar Christina
    Date:   February 16, 2019
#>

Param(
  [ValidateSet("install","uninstall", "update", "shell")]
  [String] $Action
, [string] $Package
, [string] $NoConfirm = "--confirm"
)

$bash = $Env:_MSYS2_BASH
$prefix = $Env:_MSYS2_PREFIX
if ((!$bash) -or ($bash -eq "") -or (!$prefix) -or ($prefix -eq "")) {
  throw ("Bash environment variable found, are you sure you installed cabal and msys2 via chocolatey?")
}

if(![System.IO.File]::Exists($bash)){
  throw ("Bash not found, try `choco install msys2' first.")
}

$package = "mingw-w64-${prefix}-${Package}"
$shell = $false

switch ($Action){
  "install" {
    $cmd = "-S"
    if((!$Package) -or ($Package -eq "")){
      throw ("Package name required when installing package.")
    }
    break
  }
  "uninstall" {
    $cmd = "-R"
    if((!$Package) -or ($Package -eq "")){
      throw ("Package name required when removing package.")
    }
    break
  }
  "update" {
    $cmd = "-Sy"
    $package = ""
    break
  }
  "shell" {
    $shell = $true
    break
  }
  default {
    Write-Host ".SYNOPSIS
  Install a Mingw-w64 native package such that cabal and ghc will recognize them.
.DESCRIPTION
  This CmdLet makes it easier to install native Mingw-w64 packages into MSYS2 such
  that cabal-install and GHC can use them without any other configuration required.

  This will not allow installation of MSYS2 packages.  Your global namespace will
  not be poluted by the use of this CmdLet.
.PARAMETER Action
  The action to perform. Must be one of install, uninstall, update or shell.

  - install: install a new native package
  - uninstall: remove native package
  - update: sync the repositories, will not upgrade any packages.
  - shell: open a bash shell
.PARAMETER Package
  The name of the Mingw64 package to install into the msys2 environment.
.PARAMETER NoConfirm
  Indicates whether or not an interactive prompt should be used to confirm before
  action is carried out.
.EXAMPLE
  C:\PS> mingw-pkg install gtk2 [--confirm|--noconfirm]
.NOTES
  Author: Tamar Christina
  Date:   February 16, 2019"
    return
  }
}

switch ($NoConfirm){
  "--noconfirm" {
    $arg = "--noconfirm"
    break
  }
  "--confirm" {
    $arg = "--confirm"
    break
  }
  default {
    Write-Error "Unkown option $NoConfirm. Expected --confirm or --noconfirm."
    return;
  }
}


$osBitness = "64"
if ($prefix -eq "i686") {
  $osBitness = "32"
}

# Set the APPDATA path which does not get inherited during these invokes
# and set MSYSTEM to make sure we're using the right system
$envdata = "export APPDATA=""" + $Env:AppData + """ && export MSYSTEM=MINGW" + $osBitness + " && "

if ($false -eq $shell) {
  $proc = Start-Process -NoNewWindow -UseNewEnvironment -Wait $bash `
                        -ArgumentList '--login', '-c', "'$envdata pacman $cmd $arg $package'" `
                        -PassThru

  if ((-not $ignoreExitCode) -and ($proc.ExitCode -ne 0)) {
      throw ("`'${bash}`' did not complete successfully. ExitCode: " + $proc.ExitCode)
  }
} else {
  $proc = Start-Process -NoNewWindow -UseNewEnvironment -Wait $bash `
                        -ArgumentList '--login' `
                        -PassThru
}
LICENSE.txt 
Copyright (c) 2003-2023, Cabal Development Team.
See the AUTHORS file for the full list of copyright holders.

See */LICENSE for the copyright holders of the subcomponents.

All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above
      copyright notice, this list of conditions and the following
      disclaimer in the documentation and/or other materials provided
      with the distribution.

    * Neither the name of Isaac Jones nor the names of other
      contributors may be used to endorse or promote products derived
      from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Log in or click on link to see number of positives.

In cases where actual malware is found, the packages are subject to removal. Software sometimes has false positives. Moderators do not necessarily validate the safety of the underlying software, only that a package retrieves software from the official distribution point and/or validate embedded software against official distribution point (where distribution rights allow redistribution).

Chocolatey Pro provides runtime protection from possible malware.

Add to Builder Version Downloads Last Updated Status
Cabal 3.10.2.0 76584 Saturday, November 18, 2023 Approved
Cabal 3.10.1.1 63628 Thursday, March 23, 2023 Approved
Cabal 3.8.1.0 137690 Tuesday, August 9, 2022 Approved
Cabal 3.6.2.0 162126 Wednesday, October 13, 2021 Approved
Cabal 3.6.0.0 806 Wednesday, October 13, 2021 Approved
Cabal 3.4.1.0 7577 Wednesday, October 13, 2021 Approved
Cabal 3.4.0.1-rc3 5179 Thursday, December 24, 2020 Approved
Cabal 3.4.0.0 100142 Friday, February 26, 2021 Approved
Cabal 3.4.0.0-rc5 2721 Sunday, January 3, 2021 Exempted
Cabal 3.4.0.0-rc3 365 Saturday, October 10, 2020 Exempted
Cabal 3.2.0.0 112543 Friday, April 10, 2020 Approved
Cabal 3.0.0.0 31374 Thursday, August 29, 2019 Approved
Cabal 2.4.1.0 28806 Monday, November 26, 2018 Approved
Cabal 2.4.0.20180922 2597 Sunday, September 23, 2018 Approved
Cabal 2.4.0.0 1637 Saturday, September 22, 2018 Approved
Cabal 2.2.0.0 6432 Thursday, March 29, 2018 Approved
Cabal 2.0.0.1 2828 Tuesday, February 6, 2018 Approved
Cabal 2.0.0.0 5747 Thursday, August 17, 2017 Approved
Cabal 1.24.0.2 4707 Saturday, January 14, 2017 Approved
Cabal 1.24.0.0 5061 Saturday, May 14, 2016 Approved
Cabal 1.22.0.0 441 Saturday, May 14, 2016 Approved
Cabal 1.20.0.3 492 Tuesday, May 17, 2016 Approved
Cabal 1.20.0.2 513 Saturday, May 14, 2016 Approved
Cabal 1.20.0.1 471 Saturday, May 14, 2016 Approved
Cabal 1.18.0.3 459 Saturday, May 14, 2016 Approved
Cabal 1.18.0.2 450 Saturday, May 14, 2016 Approved
Cabal 1.18.0.1 481 Saturday, May 14, 2016 Approved
Cabal 0.14.0 458 Saturday, May 14, 2016 Approved
Cabal 0.10.2 456 Saturday, May 14, 2016 Approved
Cabal 0.8.2 502 Saturday, May 14, 2016 Approved
Cabal 0.8.0 457 Saturday, May 14, 2016 Approved
Cabal 0.6.4 461 Saturday, May 14, 2016 Approved
Cabal 0.6.2 500 Saturday, May 14, 2016 Approved
Cabal 0.6.0 498 Saturday, May 14, 2016 Approved

This package has no dependencies.

Discussion for the Cabal Package

Ground Rules:

  • This discussion is only about Cabal and the Cabal package. If you have feedback for Chocolatey, please contact the Google Group.
  • This discussion will carry over multiple versions. If you have a comment about a particular version, please note that in your comments.
  • The maintainers of this Chocolatey Package will be notified about new comments that are posted to this Disqus thread, however, it is NOT a guarantee that you will get a response. If you do not hear back from the maintainers after posting a message below, please follow up by using the link on the left side of this page or follow this link to contact maintainers. If you still hear nothing back, please follow the package triage process.
  • Tell us what you love about the package or Cabal, or tell us what needs improvement.
  • Share your experiences with the package, or extra configuration or gotchas that you've found.
  • If you use a url, the comment will be flagged for moderation until you've been whitelisted. Disqus moderated comments are approved on a weekly schedule if not sooner. It could take between 1-5 days for your comment to show up.
comments powered by Disqus