Notices: This section not yet converted to new layout. Download stats are rolling back out.

76,361,128

Downloads

5,627,135

Downloads of v 0.9.9.8

6/27/2015

Last update

This is not the latest version of Chocolatey available.

Chocolatey

0.9.9.8

There are no package test results for this package

This package was approved as a trusted package on 6/27/2015.

Chocolatey is a package manager for Windows (like apt-get but for Windows). It was designed to be a decentralized framework for quickly installing applications and tools that you need. It is built on the NuGet infrastructure currently using PowerShell as its focus for delivering packages from the distros to your door, err computer.

Chocolatey is brought to you by the work and inspiration of the community, the work and thankless nights of the Chocolatey Team, with Rob heading up the direction.

You can host your own sources and add them to Chocolatey, you can extend Chocolatey's capabilities, and folks, it's only going to get better.

Commands

There are quite a few commands you can call - you should check out the command reference. Here are the most common:

  • Search - choco search something
  • List - choco list -lo
  • Install - choco install baretail
  • Pin - choco pin windirstat
  • Upgrade - choco upgrade baretail
  • Uninstall - choco uninstall baretail

    Alternative installation sources (TEMPORARILY DISABLED IN 0.9.9):

  • Install ruby gem - choco install compass -source ruby
  • Install python egg - choco install sphynx -source python
  • Install windows feature - choco install IIS -source windowsfeatures
  • Install webpi feature - choco install IIS7.5Express -source webpi

For more advanced commands and switches, use choco -? or choco command -h. You can also look at the command reference, including how you can force a package to install the x86 version of a package.

Create Packages?

We have some great guidance on how to do that. Where? I'll give you a hint, it rhymes with sticky! Wiki!

In that mess there is a link to the Helper Reference.

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

C:\> choco install chocolatey --version 0.9.9.8

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

C:\> choco upgrade chocolatey --version 0.9.9.8

Files

Hide
  • tools\chocolateyInstall.ps1 Show
    $toolsPath = (Split-Path -parent $MyInvocation.MyCommand.Definition)
    
    # ensure module loading preference is on
    $PSModuleAutoLoadingPreference = "All";
    
    $modules = Get-ChildItem $toolsPath -Filter *.psm1
    $modules | ForEach-Object {
    														$psm1File = $_.FullName;
    														$moduleName = $([System.IO.Path]::GetFileNameWithoutExtension($psm1File))
    														remove-module $moduleName -ErrorAction SilentlyContinue;
    														import-module -name  $psm1File;
    													}
    
    Initialize-Chocolatey
    
  • tools\chocolateyInstall\choco.exe Show
    md5: C008AD49012B5530A7247A0488EC079D | sha1: 4C9EB98B807353B9C1BF787A2A6C5BEE7C4B8049
  • tools\chocolateyInstall\choco.exe.ignore
  • tools\chocolateysetup.psm1 Show
    $thisScriptFolder = (Split-Path -parent $MyInvocation.MyCommand.Definition)
    $chocInstallVariableName = "ChocolateyInstall"
    $sysDrive = $env:SystemDrive
    $tempDir = $env:TEMP
    $defaultChocolateyPathOld = "$sysDrive\Chocolatey"
    #$ErrorActionPreference = 'Stop'
    $debugModeParams = $null
    
    function Initialize-Chocolatey {
    <#
      .DESCRIPTION
        This will initialize the Chocolatey tool by
          a) setting up the "nugetPath" (the location where all chocolatey nuget packages will be installed)
          b) Installs chocolatey into the "nugetPath"
                c) Instals .net 4.0 if needed
          d) Adds chocolaty to the PATH environment variable so you have access to the chocolatey|cinst commands.
      .PARAMETER  NuGetPath
        Allows you to override the default path of (C:\Chocolatey\) by specifying a directory chocolaty will install nuget packages.
    
      .EXAMPLE
        C:\PS> Initialize-Chocolatey
    
        Installs chocolatey into the default C:\Chocolatey\ directory.
    
      .EXAMPLE
        C:\PS> Initialize-Chocolatey -nugetPath "D:\ChocolateyInstalledNuGets\"
    
        Installs chocolatey into the custom directory D:\ChocolateyInstalledNuGets\
    
    #>
    param(
      [Parameter(Mandatory=$false)][string]$chocolateyPath = ''
    )
      Write-Debug "Initialize-Chocolatey"
    
      if ($env:ChocolateyEnvironmentDebug -eq 'true') {
        $debugModeParams = '-dv'
      }
    
      Install-DotNet4IfMissing
    
      $chocoNew = Join-Path $thisScriptFolder 'chocolateyInstall\choco.exe'
      & $chocoNew unpackself -fy $debugModeParams
    
      $installModule = Join-Path $thisScriptFolder 'chocolateyInstall\helpers\chocolateyInstaller.psm1'
      Import-Module $installModule -Force
    
      if ($chocolateyPath -eq '') {
        $programData = [Environment]::GetFolderPath("CommonApplicationData")
        $chocolateyPath = Join-Path "$programData" 'chocolatey'
      }
    
      # variable to allow insecure directory:
      $allowInsecureRootInstall = $false
      if ($env:ChocolateyAllowInsecureRootDirectory -eq 'true') { $allowInsecureRootInstall = $true }
    
      # if we have an already environment variable path, use it.
      $alreadyInitializedNugetPath = Get-ChocolateyInstallFolder
      if ($alreadyInitializedNugetPath -and $alreadyInitializedNugetPath -ne $chocolateyPath -and ($allowInsecureRootInstall -or $alreadyInitializedNugetPath -ne $defaultChocolateyPathOld)){
        $chocolateyPath = $alreadyInitializedNugetPath
      }
      else {
        Set-ChocolateyInstallFolder $chocolateyPath
      }
      Create-DirectoryIfNotExists $chocolateyPath
    
      Ensure-UserPermissions $chocolateyPath
    
      #set up variables to add
      $chocolateyExePath = Join-Path $chocolateyPath 'bin'
      $chocolateyLibPath = Join-Path $chocolateyPath 'lib'
    
      if ($tempDir -eq $null) {
        $tempDir = Join-Path $chocolateyPath 'temp'
        Create-DirectoryIfNotExists $tempDir
      }
    
      $yourPkgPath = [System.IO.Path]::Combine($chocolateyLibPath,"yourPackageName")
    @"
    We are setting up the Chocolatey package repository.
    The packages themselves go to `'$chocolateyLibPath`'
      (i.e. $yourPkgPath).
    A shim file for the command line goes to `'$chocolateyExePath`'
      and points to an executable in `'$yourPkgPath`'.
    
    Creating Chocolatey folders if they do not already exist.
    
    "@ | Write-Output
    
      Write-Warning "You can safely ignore errors related to missing log files when `n  upgrading from a version of Chocolatey less than 0.9.9. `n  'Batch file could not be found' is also safe to ignore. `n  'The system cannot find the file specified' - also safe."
    
      #create the base structure if it doesn't exist
      Create-DirectoryIfNotExists $chocolateyExePath
      Create-DirectoryIfNotExists $chocolateyLibPath
    
      Install-ChocolateyFiles $chocolateyPath
      Ensure-ChocolateyLibFiles $chocolateyLibPath
    
      Install-ChocolateyBinFiles $chocolateyPath $chocolateyExePath
    
      $chocolateyExePathVariable = $chocolateyExePath.ToLower().Replace($chocolateyPath.ToLower(), "%DIR%..\").Replace("\\","\")
      Initialize-ChocolateyPath $chocolateyExePath $chocolateyExePathVariable
      Process-ChocolateyBinFiles $chocolateyExePath $chocolateyExePathVariable
    
      $realModule = Join-Path $chocolateyPath "helpers\chocolateyInstaller.psm1"
      Import-Module "$realModule" -Force
    
      if (-not $allowInsecureRootInstall -and (Test-Path($defaultChocolateyPathOld))) {
        Upgrade-OldChocolateyInstall $defaultChocolateyPathOld $chocolateyPath
        Install-ChocolateyBinFiles $chocolateyPath $chocolateyExePath
      }
    
    @"
    Chocolatey (choco.exe) is now ready.
    You can call choco from anywhere, command line or powershell by typing choco.
    Run choco /? for a list of functions.
    You may need to shut down and restart powershell and/or consoles
     first prior to using choco.
    "@ | write-Output
    
      if (-not $allowInsecureRootInstall) {
        Remove-OldChocolateyInstall $defaultChocolateyPathOld
      }
    }
    
    function Set-ChocolateyInstallFolder {
    param(
      [string]$folder
    )
      Write-Debug "Set-ChocolateyInstallFolder"
    
      $environmentTarget = [System.EnvironmentVariableTarget]::User
      # removing old variable
      Install-ChocolateyEnvironmentVariable -variableName "$chocInstallVariableName" -variableValue $null -variableType $environmentTarget
      if (Test-ProcessAdminRights) {
        Write-Debug "Administrator installing so using Machine environment variable target instead of User."
        $environmentTarget = [System.EnvironmentVariableTarget]::Machine
        # removing old variable
        Install-ChocolateyEnvironmentVariable -variableName "$chocInstallVariableName" -variableValue $null -variableType $environmentTarget
      } else {
        Write-Warning "Setting ChocolateyInstall Environment Variable on USER and not SYSTEM variables.`n  This is due to either non-administrator install OR the process you are running is not being run as an Administrator."
      }
    
      Write-Output "Creating $chocInstallVariableName as an environment variable (targeting `'$environmentTarget`') `n  Setting $chocInstallVariableName to `'$folder`'"
      Write-Warning "It's very likely you will need to close and reopen your shell `n  before you can use choco."
      Install-ChocolateyEnvironmentVariable -variableName "$chocInstallVariableName" -variableValue "$folder" -variableType $environmentTarget
    }
    
    function Get-ChocolateyInstallFolder(){
      Write-Debug "Get-ChocolateyInstallFolder"
      [Environment]::GetEnvironmentVariable($chocInstallVariableName)
    }
    
    function Create-DirectoryIfNotExists($folderName){
      Write-Debug "Create-DirectoryIfNotExists"
      if (![System.IO.Directory]::Exists($folderName)) { [System.IO.Directory]::CreateDirectory($folderName) | Out-Null }
    }
    
    function Ensure-UserPermissions {
    param(
      [string]$folder
    )
      Write-Debug "Ensure-UserPermissions"
    
      if (!(Test-ProcessAdminRights)) {
        Write-Warning "User is not running elevated, cannot set user permissions."
        return
      }
    
      $currentEA = $ErrorActionPreference
      $ErrorActionPreference = 'Stop'
      try {
        # get current user
        $currentUser = [Security.Principal.WindowsIdentity]::GetCurrent()
        # get current acl
        $acl = Get-Acl $folder
    
        # define rule to set
        $rights = "Modify"
        $userAccessRule = New-Object System.Security.AccessControl.FileSystemAccessRule($currentUser.Name, $rights, "Allow")
    
        # this is idempotent
        Write-Output "Adding Modify permission for current user to '$folder'"
        $acl.SetAccessRuleProtection($false,$true)
        $acl.SetAccessRule($userAccessRule)
        Set-Acl $folder $acl
      } catch {
        Write-Warning "Not able to set permissions for user."
      }
      $ErrorActionPreference = $currentEA
    }
    
    function Upgrade-OldChocolateyInstall {
    param(
      [string]$chocolateyPathOld = "$sysDrive\Chocolatey",
      [string]$chocolateyPath =  "$($env:ALLUSERSPROFILE)\chocolatey"
    )
    
      Write-Debug "Upgrade-OldChocolateyInstall"
    
      if (Test-Path $chocolateyPathOld) {
        Write-Output "Attempting to upgrade `'$chocolateyPathOld`' to `'$chocolateyPath`'."
        Write-Warning "Copying the contents of `'$chocolateyPathOld`' to `'$chocolateyPath`'. `n This step may fail if you have anything in this folder running or locked."
        Write-Output 'If it fails, just manually copy the rest of the items out and then delete the folder.'
        Write-Host "!!!! ATTN: YOU WILL NEED TO CLOSE AND REOPEN YOUR SHELL !!!!" -ForegroundColor Magenta -BackgroundColor Black
    
        $chocolateyExePathOld = Join-Path $chocolateyPathOld 'bin'
        'Machine', 'User' |
        % {
          $path = Get-EnvironmentVariable -Name 'PATH' -Scope $_
          $updatedPath = [System.Text.RegularExpressions.Regex]::Replace($path,[System.Text.RegularExpressions.Regex]::Escape($chocolateyExePathOld) + '(?>;)?', '', [System.Text.RegularExpressions.RegexOptions]::IgnoreCase)
          if ($updatedPath -ne $path) {
            Write-Output "Updating `'$_`' PATH to reflect removal of '$chocolateyPathOld'."
            try {
              Set-EnvironmentVariable -Name 'Path' -Value $updatedPath -Scope $_ -ErrorAction Stop
            } catch {
              Write-Warning "Was not able to remove the old environment variable from PATH. You will need to do this manually"
            }
    
          }
        }
    
        Copy-Item "$chocolateyPathOld\lib\*" "$chocolateyPath\lib" -force -recurse
    
        $from = "$chocolateyPathOld\bin"
        $to = "$chocolateyPath\bin"
        $exclude = @("choco.exe", "chocolatey.exe", "cinst.exe", "clist.exe", "cpack.exe", "cpush.exe", "cuninst.exe", "cup.exe", "cver.exe", "RefreshEnv.cmd")
        Get-ChildItem -Path $from -recurse -Exclude $exclude |
          % {
            Write-Debug "Copying $_ `n to $to"
            if ($_.PSIsContainer) {
              Copy-Item $_ -Destination (Join-Path $to $_.Parent.FullName.Substring($from.length)) -Force -ErrorAction SilentlyContinue
            } else {
              $fileToMove = (Join-Path $to $_.FullName.Substring($from.length))
              try {
               Copy-Item $_ -Destination $fileToMove -Exclude $exclude -Force -ErrorAction Stop
              }
              catch {
                Write-Warning "Was not able to move `'$fileToMove`'. You may need to reinstall the shim"
              }
            }
          }
      }
    }
    
    function Remove-OldChocolateyInstall {
    param(
      [string]$chocolateyPathOld = "$sysDrive\Chocolatey"
    )
      Write-Debug "Remove-OldChocolateyInstall"
    
      if (Test-Path $chocolateyPathOld) {
        Write-Warning "This action will result in Log Errors, you can safely ignore those. `n You may need to finish removing '$chocolateyPathOld' manually."
        try {
          Get-ChildItem -Path "$chocolateyPathOld" | % {
            if (Test-Path $_.FullName) {
              Write-Debug "Removing $_ unless matches .log"
              Remove-Item $_.FullName -exclude *.log -recurse -force -ErrorAction SilentlyContinue
            }
          }
    
          Write-Output "Attempting to remove `'$chocolateyPathOld`'. This may fail if something in the folder is being used or locked."
          Remove-Item "$($chocolateyPathOld)" -force -recurse -ErrorAction Stop
        }
        catch {
          Write-Warning "Was not able to remove `'$chocolateyPathOld`'. You will need to manually remove it."
        }
      }
    }
    
    function Install-ChocolateyFiles {
    param(
      [string]$chocolateyPath
    )
      Write-Debug "Install-ChocolateyFiles"
    
      Write-Debug "Removing install files in chocolateyInstall, helpers, redirects, and tools"
      "$chocolateyPath\chocolateyInstall", "$chocolateyPath\helpers", "$chocolateyPath\redirects", "$chocolateyPath\tools" | % {
        #Write-Debug "Checking path $_"
    
        if (Test-Path $_) {
          Get-ChildItem -Path "$_" | % {
            #Write-Debug "Checking child path $_ ($($_.FullName))"
            if (Test-Path $_.FullName) {
              Write-Debug "Removing $_ unless matches .log"
              Remove-Item $_.FullName -exclude *.log -recurse -force -ErrorAction SilentlyContinue
            }
          }
        }
      }
    
      Write-Debug "Attempting to move choco.exe to choco.exe.old so we can place the new version here."
      # rename the currently running process / it will be locked if it exists
      $chocoExe = Join-Path $chocolateyPath 'choco.exe'
      if (Test-Path ($chocoExe)) {
        Write-Debug "Renaming '$chocoExe' to '$chocoExe.old'"
        try {
          Remove-Item "$chocoExe.old" -force -ErrorAction SilentlyContinue
          Move-Item $chocoExe "$chocoExe.old" -force -ErrorAction SilentlyContinue
        }
        catch {
          Write-Warning "Was not able to rename `'$chocoExe`' to `'$chocoExe.old`'."
        }
      }
    
      Write-Debug "Unpacking files required for Chocolatey."
      $chocInstallFolder = Join-Path $thisScriptFolder "chocolateyInstall"
      $chocoExe = Join-Path $chocInstallFolder 'choco.exe'
      $chocoExeDest = Join-Path $chocolateyPath 'choco.exe'
      Copy-Item $chocoExe $chocoExeDest -force
    
      & $chocoExeDest unpackself -fy $debugModeParams
    }
    
    function Ensure-ChocolateyLibFiles {
    param(
      [string]$chocolateyLibPath
    )
      Write-Debug "Ensure-ChocolateyLibFiles"
      $chocoPkgDirectory = Join-Path $chocolateyLibPath 'chocolatey'
    
      if ( -not (Test-Path("$chocoPkgDirectory\chocolatey.nupkg")) ) {
        Write-Output "Ensuring '$chocoPkgDirectory' exists."
        Create-DirectoryIfNotExists $chocoPkgDirectory
    
        $chocoPkg = Get-ChildItem "$thisScriptFolder/../../" | ?{$_.name -match "^chocolatey.*nupkg"} | Sort name -Descending | Select -First 1
        if ($chocoPkg -ne '') { $chocoPkg = $chocoPkg.FullName }
        "$tempDir\chocolatey.zip", "$chocoPkg" | % {
          if ($_ -ne $null -and $_ -ne '') {
            if (Test-Path $_) {
              Copy-Item $_ "$chocoPkgDirectory\chocolatey.nupkg" -force -ErrorAction SilentlyContinue
            }
          }
        }
      }
    }
    
    function Install-ChocolateyBinFiles {
    param(
      [string] $chocolateyPath,
      [string] $chocolateyExePath
    )
      Write-Debug "Install-ChocolateyBinFiles"
      Write-Debug "Installing the bin file redirects"
      $redirectsPath = Join-Path $chocolateyPath 'redirects'
      if (!(Test-Path "$redirectsPath")) {
        Write-Warning "$redirectsPath does not exist"
        return
      }
    
      $exeFiles = Get-ChildItem "$redirectsPath" -include @("*.exe","*.cmd") -recurse
      foreach ($exeFile in $exeFiles) {
        $exeFilePath = $exeFile.FullName
        $exeFileName = [System.IO.Path]::GetFileName("$exeFilePath")
        $binFilePath = Join-Path $chocolateyExePath $exeFileName
        $binFilePathRename = $binFilePath + '.old'
        $batchFilePath = $binFilePath.Replace(".exe",".bat")
        $bashFilePath = $binFilePath.Replace(".exe","")
        if (Test-Path ($batchFilePath)) { Remove-Item $batchFilePath -force -ErrorAction SilentlyContinue }
        if (Test-Path ($bashFilePath)) { Remove-Item $bashFilePath -force -ErrorAction SilentlyContinue }
        if (Test-Path ($binFilePathRename)) {
          try {
            Write-Debug "Attempting to remove $binFilePathRename"
            Remove-Item $binFilePathRename -force -ErrorAction Stop
          }
          catch {
            Write-Warning "Was not able to remove `'$binFilePathRename`'. This may cause errors."
          }
        }
        if (Test-Path ($binFilePath)) {
         try {
            Write-Debug "Attempting to rename $binFilePath to $binFilePathRename"
            Move-Item -path $binFilePath -destination $binFilePathRename -force -ErrorAction Stop
          }
          catch {
            Write-Warning "Was not able to rename `'$binFilePath`' to `'$binFilePathRename`'."
          }
        }
    
        try {
          Write-Debug "Attempting to copy $exeFilePath to $binFilePath"
          Copy-Item -path $exeFilePath -destination $binFilePath -force -ErrorAction Stop
        }
        catch {
          Write-Warning "Was not able to replace `'$binFilePath`' with `'$exeFilePath`'. You may need to do this manually."
        }
    
        $commandShortcut = [System.IO.Path]::GetFileNameWithoutExtension("$exeFilePath")
        Write-Debug "Added command $commandShortcut"
      }
    }
    
    function Initialize-ChocolateyPath {
    param(
      [string]$chocolateyExePath = "$($env:ALLUSERSPROFILE)\chocolatey\bin",
      [string]$chocolateyExePathVariable = "%$($chocInstallVariableName)%\bin"
    )
      Write-Debug "Initialize-ChocolateyPath"
      Write-Debug "Initializing Chocolatey Path if required"
      $environmentTarget = [System.EnvironmentVariableTarget]::User
      if (Test-ProcessAdminRights) {
        Write-Debug "Administrator installing so using Machine environment variable target instead of User."
        $environmentTarget = [System.EnvironmentVariableTarget]::Machine
      } else {
        Write-Warning "Setting ChocolateyInstall Path on USER PATH and not SYSTEM Path.`n  This is due to either non-administrator install OR the process you are running is not being run as an Administrator."
      }
    
      Install-ChocolateyPath -pathToInstall "$chocolateyExePath" -pathType $environmentTarget
    }
    
    function Process-ChocolateyBinFiles {
    param(
      [string]$chocolateyExePath = "$($env:ALLUSERSPROFILE)\chocolatey\bin",
      [string]$chocolateyExePathVariable = "%$($chocInstallVariableName)%\bin"
    )
      Write-Debug "Process-ChocolateyBinFiles"
      $processedMarkerFile = Join-Path $chocolateyExePath '_processed.txt'
      if (!(test-path $processedMarkerFile)) {
        $files = get-childitem $chocolateyExePath -include *.bat -recurse
        if ($files -ne $null -and $files.Count -gt 0) {
          Write-Debug "Processing Bin files"
          foreach ($file in $files) {
            Write-Output "Processing $($file.Name) to make it portable"
            $fileStream = [System.IO.File]::Open("$file", 'Open', 'Read', 'ReadWrite')
            $reader = New-Object System.IO.StreamReader($fileStream)
            $fileText = $reader.ReadToEnd()
            $reader.Close()
            $fileStream.Close()
    
            $fileText = $fileText.ToLower().Replace("`"" + $chocolateyPath.ToLower(), "SET DIR=%~dp0%`n""%DIR%..\").Replace("\\","\")
    
            Set-Content $file -Value $fileText -Encoding Ascii
          }
        }
    
        Set-Content $processedMarkerFile -Value "$([System.DateTime]::Now.Date)" -Encoding Ascii
      }
    }
    
    $netFx4InstallTries = 0
    
    function Install-DotNet4IfMissing {
    param(
      $forceFxInstall = $false
    )
      # we can't take advantage of any chocolatey module functions, because they
      # haven't been unpacked because they require .NET Framework 4.0
    
      Write-Debug "Install-DotNet4IfMissing"
      if ([IntPtr]::Size -eq 8) {$fx="framework64"} else {$fx="framework"}
    
      $NetFx4ClientUrl = 'http://download.microsoft.com/download/5/6/2/562A10F9-C9F4-4313-A044-9C94E0A8FAC8/dotNetFx40_Client_x86_x64.exe'
      $NetFx4FullUrl = 'http://download.microsoft.com/download/9/5/A/95A9616B-7A37-4AF6-BC36-D6EA96C8DAAE/dotNetFx40_Full_x86_x64.exe'
      $NetFx4Url = $NetFx4FullUrl
      $NetFx4Path = "$tempDir"
      $NetFx4InstallerFile = 'dotNetFx40_Full_x86_x64.exe'
      $NetFx4Installer = Join-Path $NetFx4Path $NetFx4InstallerFile
    
      if(!(test-path "$env:windir\Microsoft.Net\$fx\v4.0.30319") -or $forceFxInstall) {
        if (!(Test-Path $NetFx4Path)) {
          Write-Host "Creating folder `'$NetFx4Path`'"
          $null = New-Item -Path "$NetFx4Path" -ItemType Directory
        }
    
        $netFx4InstallTries += 1
    
        if (!(Test-Path $NetFx4Installer)) {
          Write-Host "Downloading `'$NetFx4Url`' to `'$NetFx4Installer`' - the installer is 40+ MBs, so this could take awhile on a slow connection."
          (New-Object Net.WebClient).DownloadFile("$NetFx4Url","$NetFx4Installer")
        }
    
        $psi = New-Object System.Diagnostics.ProcessStartInfo
        $psi.WorkingDirectory = "$NetFx4Path"
        $psi.FileName = "$NetFx4InstallerFile"
        # https://msdn.microsoft.com/library/ee942965(v=VS.100).aspx#command_line_options
        # http://blogs.msdn.com/b/astebner/archive/2010/05/12/10011664.aspx
        # For the actual setup.exe (if you want to unpack first) - /repair /x86 /x64 /ia64 /parameterfolder Client /q /norestart
        $psi.Arguments = "/q /norestart /repair"
    
        Write-Host "Installing `'$NetFx4Installer`' - this may take awhile with no output."
        $s = [System.Diagnostics.Process]::Start($psi);
        $s.WaitForExit();
        if ($s.ExitCode -ne 0 -and $s.ExitCode -ne 3010) {
          if ($netFx4InstallTries -eq 2) {
            Write-Error ".NET Framework install failed with exit code `'$($s.ExitCode)`'. `n This will cause the rest of the install to fail."
            throw "Error installing .NET Framework 4.0 (exit code $($s.ExitCode)). `n Please install the .NET Framework 4.0 manually and then try to install Chocolatey again. `n Download at `'$NetFx4Url`'"
          } else {
            Write-Warning "First try of .NET framework install failed with exit code `'$($s.ExitCode)`'. Trying again."
            Install-DotNet4IfMissing $true
          }
        }
      }
    }
    
    Export-ModuleMember -function Initialize-Chocolatey;
    
  • tools\init.ps1 Show
    param($installPath, $toolsPath, $package, $project)
    
    $modules = Get-ChildItem $ToolsPath -Filter *.psm1
    $modules | ForEach-Object { import-module -name  $_.FullName }
    
    @"
    ========================
    Chocolatey
    ========================
    Welcome to Chocolatey, your local machine repository built on the NuGet infrastructure. Chocolatey allows you to install application packages to your machine with the goodness of a #chocolatey #nuget combo. 
    Application executables get added to the path automatically so you can call them from anywhere (command line/powershell prompt), not just in Visual Studio.
    
    Lets get Chocolatey!
    ----------
    Visual Studio -
    ----------
    Please run Initialize-Chocolatey one time per machine to set up the repository. 
    If you are upgrading, please remember to run Initialize-Chocolatey again.
    After you have run Initiliaze-Chocolatey, you can safely uninstall the chocolatey package from your current Visual Studio solution.
    ----------
    Alternative NuGet -
    ----------
    If you are not using NuGet in Visual Studio, please navigate to the directory with the chocolateysetup.psm1 and run that in Powershell, followed by Initialize-Chocolatey.
    Upgrade is the same, just run Initialize-Chocolatey again.
    ----------
    Once you've run initialize or upgrade, you can uninstall this package from the local project without affecting your chocolatey repository.
    ========================
    "@ | Write-Host
    

Virus Scan Results

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.

Dependencies

This package has no dependencies.

Maintainer(s)

Software Author(s)

  • Rob Reynolds
  • The Chocolatey Team

Copyright

RealDimensions Software, LLC - 2011-Present

Tags

Release Notes

See all - https://github.com/chocolatey/choco/blob/master/CHANGELOG.md

0.9.9.8

BUG FIXES

  • Fix: choco install -y C: deletes all files - see #341
  • Fix: Read-Host halts scripts rather than prompt for input - see #219

IMPROVEMENTS

  • Download Progress Bar is Missing - see #56

0.9.9.7

"Fix Everything. Fix All The Things" - There have been some things bugging us for a long time related to limitations with NuGet, so we decided to fix that. Like nuspec enhancements, that crazy content folder restriction has been removed (I know, right?!), and we're working around badly behaved packages quite a bit more to bring you more feature parity.

Let's talk about a couple of big, like really big, BIG features just added with this release. No more packages rebooting Windows. We fixed (#304 / #323) and enhanced up the Auto Uninstaller Service quite a bit to ensure things are working like you would expect (It goes on by default in 0.9.10 - we'll start documenting more about it soon). But wait, there's more! I haven't even told you about the big features yet

The first big feature is enhancing the nuspec. I mentioned this I know, but now you can use packageSourceUrl in the nuspec to tell folks where you are storing the source for the package! We also added projectSourceUrl, docsUrl, mailingListUrl, and bugTrackerUrl. What's even better is that the community feed has already been enhanced to look for these values. So have the templates from choco new. And it's backwards compatible, meaning you can still install packages that have these added nuspec enhancements without issue (but we will need to provide a fix for Nuget Package Explorer).

The second is Xml Document Transformations (XDT), which I think many folks are aware of but may not realize what it can provide. NuGet has allowed transformations for quite awhile to allow you to make changes to an app.config/web.config on install/uninstall. We are following in similar footsteps to allow you to do similar when installing/upgrading packages. We will look for *.install.xdt files in the package (doesn't matter where) and they will apply to configuration files with the same name in the package. This means that during upgrades we won't overwrite configuration files during upgrades that have opted into this feature. It allows you to give users a better experience during upgrades because they won't need to keep making the same changes to the xml config files each time they upgrade your package.

FEATURES

  • Allow XDT Configuration Transforms - see #331
  • Prevent reboots - see #316
  • Enhance the nuspec - first wave - see #205
  • Uninstaller Service Enhancements - see #305

BUG FIXES

  • When uninstall fails, do not continue removing files - see #315
  • Do not run autouninstaller if the package result is already a failure - see #323
  • Fix - Auto Uninstaller can fail if chocolateyUninstall.ps1 uninstalls prior to it running - see #304
  • Fix - Packages with content folders cannot have a dependency without also having a content folder - see #290
  • Remove ShimGen director files on upgrade/uninstall - see #326
  • If feature doesn't exist, throw an error - see #317
  • Fix - The operation completed successfully on stderr - see #249
  • Fix - When specific nuget version is needed by a package it is the chocolatey version that is used - see #194
  • When installing with *.nupkg, need to get package name from package, not file name - see #90
  • Fix - Choco pin list is not returning a list - see #302
  • Fix - A pin is not created for existing installations (prior to new choco) - see #60

IMPROVEMENTS

  • Allow upgrade to always install missing packages - see #300
  • Enhance Templates - see #296
  • Always log debug output to the log file - see #319
  • Warn when unable to snapshot locked files - see #313
  • Use %systemroot% in place of %windir%. PATH exceed 2048 breaks choco - see #252

0.9.9.6

Some really large fixes this release, especially removing all files that are installed to the package directory if they haven't changed, including ensuring that the nupkg file is always removed on successful uninstalls. The really big add some folks are going to like is the new outdated command. Some more variables that were misused have been brought back, which allows some packages (like Atom) to be installed again without issue. If you can believe some people never read these, we decided to add a note to the installer prompt to let people know about -y.

FEATURES

  • Outdated Command - Use choco outdated to see outdated packages - see #170

BUG FIXES

  • Fix - NotSilent Switch Not Working - see #281
  • Fix - Silent installation of choco without admin is not possible - see #274
  • Fix - Package resolves to latest version from any source - see #279
  • Fix - Install fails when shortcut creation fails - see #264
  • Fix - Error deserializing response of type Registry - see #257
  • Fix - Auto uninstaller should not depend on optional InstallLocation value - see #255
  • Fix - Nupkg is left but reported as successfully uninstalled by NuGet - see #254
  • Fix - SHA1 checksum compared as MD5 for Install-ChocolateyZipPackage - see #253
  • Fix - Auto uninstaller strips off "/" and "-" in arguments - see #212

IMPROVEMENTS

  • Uninstall removes all installed files if unchanged - see #121
  • Auto uninstaller should convert /I to /X for Msi Uninstalls - see #271
  • Bring back more variables for feature parity - see #267
  • Mention -y in the prompt - see #265

0.9.9.5

BREAKING CHANGES

  • Renamed short option p to i for list --include-programs so that p could be ubiquitous for password across commands that optionally can pass a password - see #240

BUG FIXES

  • Fix - Secure Sources Not Working - see #240
  • Fix - Generate-BinFile / Remove-BinFile - see #230
  • Fix - cpack should only include files from nuspec - see #232
  • Fix - cpack should leave nupkg in current directory - see #231
  • Fix - Install-PowerShellCommand uses incorrect path - see #241
  • Fix - choco list source with redirects does not resolve - see #171
  • Fix - choco tried to resolve disabled repo - see #169
  • Fix - cpack nuspec results in "The path is not of a legal form" - see #164
  • Fix - cpack hangs on security related issue - see #160
  • Fix - spelling error in "package has been upgradeed successfully" - see #64

IMPROVEMENTS

  • Api Key and Source matching could be more intuitive - see #228
  • Remove warning about allowGlobalConfirmation being enabled - see #237
  • Include log file path when saying 'See the log for details' - see #187
  • Uninstall prompts for version when there is only one installed - see #186
  • Do not offer a default option when prompting for a user choice - see #185
  • Remove the warning note about skipping, and instead show the warning when selecting skip - see #183
  • Do not print PowerShell install/update scripts by default - see #182

0.9.9.4

BUG FIXES

  • Fix - The term 'false' is not recognized as the name of a cmdlet - see #215

IMPROVEMENTS

  • Some packages use non-API variables like $installArguments - see #207

0.9.9.3

BUG FIXES

  • Fix - Install .NET Framework immediately during install - see #168
  • Fix - Do not error on Set-Acl during install/upgrade - see #163
  • Fix - Do not escape curly braces in powershell script - see #208
  • Fix - Formatting issues on --noop command logging - see #202
  • Fix - Uninstaller check doesn't find 32-bit registry keys - see #197
  • Fix - Uninstaller errors on short path to msiexec - see #211

IMPROVEMENTS

  • Some packages use non-API variables like $installArguments - see #207
  • Add Generate-BinFile to Helpers (widely used but never part of API) - see #145
  • Add Remove-BinFile to Helpers - see #195
  • Get-ChocolateyWebFile should create path if it doesn't exist - see #167

0.9.9.2

BUG FIXES

  • Fix - Allow passing install arguments again (regression in 0.9.9 series) - see #150
  • Fix - Allow apostrophes to be used as quotes - quoting style that worked with previous client - see #141
  • Fix - Shims write errors to stderr - see #142 and ShimGen #14

IMPROVEMENTS

  • Upgrade -r should always return a value - see #153

0.9.9.1

BUG FIXES

  • Fix - Get-BinRoot broken - see #144

0.9.9

This also includes issues that were being tracked in the old Chocolatey repository: Chocolatey 0.9.9.

The two links above will not capture everything that has changed, since this is a complete rewrite. We broke everything. If this were a v1+, it would be a major release. But we are less than v1, so 0.9.9 it is! ;)

Okay, so we didn't really break everything. We have maintained nearly full compatibility with how you pass options into choco, although the output may be a bit different (but better, we hope) and in at least one case, additional switches (or a feature setting) is/are required - we limited this to security related changes only.

We also fixed and improved a bunch of things, so we feel the trade off is well worth the changes.

We'll try to capture everything here that you should know about. Please call choco -? or choco.exe -h to get started.

KNOWN ISSUES

  • Known Issues
  • TEMPORARY install all is missing - this is expected to be back in 0.9.10 - see #23
  • Alternative sources (webpi,ruby,python,cygwin, windowsfeature) do not work yet. This is expected to be fixed in 0.9.10 - see #14
  • Progress bar is missing when downloading until we are using internal posh components for Packages - see #56
  • See Feature Parity for items not yet reimplemented from older PowerShell Chocolatey client (v0.9.8.32 and below).

BREAKING CHANGES

  • [Security] Prompt for confirmation: For security reasons, we now stop for confirmation before changing the state of the system on most commands. You can pass -y to confirm any prompts or set a value in the config that will globally confirm - see #52 (NOTE: This is one of those additional switches we were talking about)
  • [Security] If your default installation is still at c:\Chocolatey, this version will force a move to ProgramData and update the environment settings - see #7
  • Configuration Breaking Changes:

    1. You now have one config file to interact with in %ChocolateyInstall%\config - your user config is no longer valid and can be removed once you migrate settings to the config.

    2. The config will no longer be overwritten on upgrade.

    3. Choco no longer interacts with NuGet's config file at all. You will need to reset all of your apiKeys (see features for apikey). On the plus side, the keys will work for all users of the machine, unlike NuGet's apiKeys (only work for the user that sets them).

    4. This also means you can no longer use useNugetForSources. It has been removed as a config setting.

  • Packaging Changes:

    1. Choco now installs packages without version numbers on folders. This means quite a few things...

    2. Upgrading packages doesn't install a new version next to an old version, it actually upgrades.

    3. Dependencies resolve at highest available version, not the minimum version as before - see Chocolatey #415

  • Package Maintenance Changes:

    1. Read the above about apikey changes

    2. Read above about dependency resolution changes.

  • Deprecated/Removed Commands:

    1. installmissing has been removed. It was deprecated awhile ago, so this should not be a surprise.

    2. choco version has been deprecated and will be removed in v1. Use choco upgrade pkgName --noop or choco upgrade pkgName -whatif instead.

    3. Write-ChocolateySuccess, Write-ChocolateyFailure have been deprecated.

    4. update is now upgrade. update has been deprecated and will be removed/replaced in v1. Update will be reincarnated later for a different purpose. Hint: It rhymes with smackage pindexes.

FEATURES

BUG FIXES

Probably a lot of bug fixes that may not make it here, but here are the ones we know about.

IMPROVEMENTS

  • [Security] Allow keeping c:\chocolatey install directory with environment variable - see #17
  • [Security] Require switch on unofficial build - see #36
  • Install script updates - see #7
  • Ensure Chocolatey pkg is installed properly in lib folder - This means you can take a dependency on a minimum version of Chocolatey (we didn't like that before) - see #19
  • Uninstall - allow abort - see #43
  • Support for HTTPS basic authorization - see Chocolatey #128
  • Smooth out success/failure logging - see Chocolatey #154
  • Add $env:CHOCOLATEY_VERSION - see Chocolatey #251
  • Replace ascii cue with visual cues - see Chocolatey #376
  • Uninstall all versions of an app - see Chocolatey #389
  • Add parameters in packages.config files - see Packages.config, Chocolatey #472, and #10
  • Choco pack should support -version - see Chocolatey #526
  • Enhancements to Start-ChocolateyProcessAsAdmin - see Chocolatey #564
  • Install-ChocolateyFileAssociation - add label to new file types - see Chocolatey #564
  • Clean up the verobsity of Chocolatey - see Chocolatey #374
  • Compact choco upgrade --noop option - see Chocolatey #414
  • Remove references to the Chocolatey gods - see Chocolatey #669
  • Shims now have noop (--shimgen-noop) and help (--shimgen-help) switches - see ShimGen #8 and ShimGen #10
  • Shims will terminate underlying process on termination signal - see ShimGen #11
  • Shims now have gui (--shimgen-gui) and exit (--shimgen-exit) switches - see ShimGen #13 and ShimGen #12
  • Dat help menu tho. I mean srsly guise - see Chocolatey #641

Version History

Version Downloads Last updated Status
Chocolatey 0.10.6.1 844187 Saturday, June 3, 2017 approved
Chocolatey 0.10.6 412447 Thursday, June 1, 2017 approved
Chocolatey 0.10.6-beta-20170531 341 Thursday, June 1, 2017 approved
Chocolatey 0.10.6-beta-20170503 7428 Wednesday, May 3, 2017 approved
Chocolatey 0.10.5 18002320 Thursday, March 30, 2017 approved
Chocolatey 0.10.4 173543 Thursday, March 30, 2017 approved
Chocolatey 0.10.4-beta1-20170326 275 Sunday, March 26, 2017 approved
Chocolatey 0.10.4-beta1-20170323 115 Thursday, March 23, 2017 approved
Chocolatey 0.10.3 25294364 Friday, October 7, 2016 approved
Show More

Discussion for the Chocolatey Package

Ground rules:

  • This discussion is only about Chocolatey and the Chocolatey 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 Chocolatey, 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