Honour NO_COLOR in bootstrap scrips, fixes #248

Fixes after formatting changes.

.gitlab-ci.yml

@@ -14,7 +14,7 @@ variables:
 ############################################################
 
 .debian:
-  image: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb9:$DOCKER_REV"
+  image: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb10:$DOCKER_REV"
   tags:
     - x86_64-linux
   variables:
@@ -49,6 +49,7 @@ variables:
     OS: "LINUX"
     ARCH: "ARM"
     CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+  retry: 2
 
 .linux:aarch64:
   image: "registry.gitlab.haskell.org/ghc/ci-images/aarch64-linux-deb10:$DOCKER_REV"
@@ -75,7 +76,15 @@ variables:
     ARCH: "ARM64"
     CABAL_DIR: "$CI_PROJECT_DIR/cabal"
 
-.freebsd:
+.freebsd13:
+  tags:
+    - x86_64-freebsd13
+  variables:
+    OS: "FREEBSD"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.freebsd12:
   tags:
     - x86_64-freebsd
   variables:
@@ -90,6 +99,7 @@ variables:
     OS: "WINDOWS"
     ARCH: "64"
     CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+  retry: 2
 
 .root_cleanup:
   after_script:
@@ -103,7 +113,7 @@ variables:
   artifacts:
     expire_in: 2 week
     paths:
-      - golden
+      - test/golden
       - dist-newstyle/cache/
     when: on_failure
 
@@ -173,10 +183,18 @@ variables:
     runInNixShell ./.gitlab/before_script/darwin/install_deps.sh 2>&1
     runInNixShell ./.gitlab/script/ghcup_version.sh 2>&1
 
-.test_ghcup_version:freebsd:
+.test_ghcup_version:freebsd12:
   extends:
     - .test_ghcup_version
-    - .freebsd
+    - .freebsd12
+    - .root_cleanup
+  before_script:
+    - ./.gitlab/before_script/freebsd/install_deps.sh
+
+.test_ghcup_version:freebsd13:
+  extends:
+    - .test_ghcup_version
+    - .freebsd13
     - .root_cleanup
   before_script:
     - ./.gitlab/before_script/freebsd/install_deps.sh
@@ -240,7 +258,7 @@ test:linux:bootstrap_script:
 test:windows:bootstrap_powershell_script:
   stage: test
   script:
-    - ./bootstrap-haskell.ps1 -InstallDir $CI_PROJECT_DIR -BootstrapUrl $CI_PROJECT_DIR/bootstrap-haskell -InBash
+    - ./scripts/bootstrap/bootstrap-haskell.ps1 -InstallDir $CI_PROJECT_DIR -BootstrapUrl $CI_PROJECT_DIR/bootstrap-haskell -InBash
   after_script:
     - "[Environment]::SetEnvironmentVariable('GHCUP_INSTALL_BASE_PREFIX', $null, [System.EnvironmentVariableTarget]::User)"
     - "[Environment]::SetEnvironmentVariable('GHCUP_MSYS2', $null, [System.EnvironmentVariableTarget]::User)"
@@ -263,6 +281,23 @@ test:linux:
     CABAL_VERSION: "3.4.0.0"
   needs: []
 
+test:linux:hls:
+  stage: test
+  extends:
+    - .test_ghcup_version
+    - .debian
+  variables:
+    GHC_VERSION: "8.10.7"
+    HLS_TARGET_VERSION: "1.4.0"
+    CABAL_VERSION: "3.6.0.0"
+  needs: []
+  when: manual
+  allow_failure: true
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps.sh
+  script:
+    - ./.gitlab/script/ghcup_hls.sh
+
 test:linux:cross-armv7:
   stage: test
   extends:
@@ -355,9 +390,19 @@ test:mac:aarch64:
 
 ######## freebsd test ########
 
-test:freebsd:
+test:freebsd12:
   stage: test
-  extends: .test_ghcup_version:freebsd
+  extends: .test_ghcup_version:freebsd12
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  allow_failure: true # freebsd runners are unreliable
+  when: manual
+  needs: []
+
+test:freebsd13:
+  stage: test
+  extends: .test_ghcup_version:freebsd13
   variables:
     GHC_VERSION: "8.10.4"
     CABAL_VERSION: "3.4.0.0"
@@ -491,11 +536,26 @@ release:darwin:aarch64:
 
 ######## freebsd release ########
 
-release:freebsd:
+release:freebsd12:
   stage: release
-  needs: ["test:freebsd"]
+  needs: ["test:freebsd12"]
   extends:
-    - .freebsd
+    - .freebsd12
+    - .release_ghcup
+    - .root_cleanup
+  before_script:
+    - ./.gitlab/before_script/freebsd/install_deps.sh
+  variables:
+    ARTIFACT: "x86_64-portbld-freebsd-ghcup"
+    GHC_VERSION: "8.10.6"
+    CABAL_VERSION: "3.4.0.0"
+  allow_failure: true
+
+release:freebsd13:
+  stage: release
+  needs: ["test:freebsd13"]
+  extends:
+    - .freebsd13
     - .release_ghcup
     - .root_cleanup
   before_script:
@@ -527,15 +587,9 @@ release:windows:
 hlint:
   stage: hlint
   extends:
-    - .alpine:64bit
+    - .debian
-  before_script:
-    - ./.gitlab/before_script/linux/alpine/install_deps.sh
   script:
-    - ./.gitlab/script/hlint.sh
+    - curl -sSL https://raw.github.com/ndmitchell/hlint/master/misc/run.sh | sh -s -- -r lib/ test/
-  variables:
-    GHC_VERSION: "8.10.6"
-    CABAL_VERSION: "3.4.0.0"
-    JSON_VERSION: "0.0.4"
   allow_failure: true
   artifacts:
     expire_in: 2 week

.gitlab/before_script/freebsd/install_deps.sh

@@ -11,9 +11,9 @@ mkdir -p "${TMPDIR}"
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-portbld-freebsd-ghcup > ./ghcup-bin
 chmod +x ghcup-bin
 
-./ghcup-bin upgrade -i -f
+./ghcup-bin -v upgrade -i -f
-./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin -v install ${GHC_VERSION}
-./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin -v set ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin -v install-cabal ${CABAL_VERSION}
 
 exit 0

.gitlab/before_script/linux/alpine/install_deps.sh

@@ -52,3 +52,7 @@ apk add --no-cache \
 	xz-dev \
 	ncurses-static
 
+if [ "${ARCH}" = "32" ] ; then
+	apk add --no-cache \
+		bsd-compat-headers
+fi

.gitlab/before_script/linux/install_deps.sh

@@ -7,67 +7,21 @@ set -eux
 mkdir -p "${TMPDIR}"
 
 sudo apt-get update -y
-sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget lsb-release software-properties-common gnupg2 apt-transport-https
+sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget lsb-release software-properties-common gnupg2 apt-transport-https gcc autoconf automake build-essential
 
 if [ "${CROSS}" = "arm-linux-gnueabihf" ] ; then
-	sudo apt-get install -y autoconf build-essential gcc-arm-linux-gnueabihf
+	sudo apt-get install -y gcc-arm-linux-gnueabihf
 	sudo dpkg --add-architecture armhf
 	sudo apt-get update -y
 	sudo apt-get install -y libncurses-dev:armhf
 fi
 
-case "${ARCH}" in
+export BOOTSTRAP_HASKELL_NONINTERACTIVE=1
-	ARM*)
+export BOOTSTRAP_HASKELL_GHC_VERSION=$GHC_VERSION
-		case "${ARCH}" in
+export BOOTSTRAP_HASKELL_CABAL_VERSION=$CABAL_VERSION
-			"ARM")
+export BOOTSTRAP_HASKELL_VERBOSE=1
-				ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-armv7-deb10-linux.tar.xz
-				cabal_url=home.smart-cactus.org/~ben/cabal-install-${CABAL_VERSION}-armv7-linux-bootstrapped.tar.xz
-				;;
-			"ARM64")
-				ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-aarch64-deb10-linux.tar.xz
-				cabal_url=https://downloads.haskell.org/~cabal/cabal-install-${CABAL_VERSION}/cabal-install-${CABAL_VERSION}-aarch64-ubuntu-18.04.tar.xz
-				;;
-			*)
-				exit 1 ;;
-		esac
 
-		mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
+curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh
 
-		curl -O "${ghc_url}"
+rm "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/ghcup
-		tar -xf ghc-*.tar.*
-		cd ghc-${GHC_VERSION}
-		./configure --prefix="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}
-		make install
-		for i in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}/bin/*-${GHC_VERSION} ; do
-			ln -s "${i}" "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/${i##*/}
-		done
-		for x in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/*-${GHC_VERSION} ; do
-			ln -s ${x##*/} ${x%-${GHC_VERSION}}
-		done
-		cd ..
-		rm -rf ghc-${GHC_VERSION} ghc-*.tar.*
-		unset x i
-
-		mkdir cabal-install
-		cd cabal-install
-		curl -O "${cabal_url}"
-		tar -xf cabal-install-*
-		mv cabal "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/cabal
-		cd ..
-		rm -rf cabal-install
-
-		;;
-	*) 
-		url=https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup
-
-		curl -sSfL "${url}" > ./ghcup-bin
-		chmod +x ghcup-bin
-
-		./ghcup-bin upgrade -i -f
-		./ghcup-bin install ghc ${GHC_VERSION}
-		./ghcup-bin set ghc ${GHC_VERSION}
-		./ghcup-bin install cabal ${CABAL_VERSION}
-
-		;;
-esac
 

.gitlab/ghcup_env

@@ -1,9 +1,11 @@
 if [ "${OS}" = "WINDOWS" ] ; then
 	export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
-	export PATH="$GHCUP_INSTALL_BASE_PREFIX/ghcup/bin:$CI_PROJECT_DIR/.local/bin:$PATH"
+	export GHCUP_BIN="$CI_PROJECT_DIR/ghcup/bin"
+	export PATH="$GHCUP_BIN:$CI_PROJECT_DIR/.local/bin:$PATH"
 	export TMPDIR="$CI_PROJECT_DIR/tmp"
 else
 	export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
-	export PATH="$CI_PROJECT_DIR/.ghcup/bin:$CI_PROJECT_DIR/.local/bin:/opt/llvm/bin:$PATH"
+	export GHCUP_BIN="$CI_PROJECT_DIR/.ghcup/bin"
+	export PATH="$GHCUP_BIN:$CI_PROJECT_DIR/.local/bin:/opt/llvm/bin:$PATH"
 	export TMPDIR="$CI_PROJECT_DIR/tmp"
 fi

.gitlab/script/ghcup_bootstrap.sh

@@ -24,7 +24,7 @@ export BOOTSTRAP_HASKELL_NONINTERACTIVE=yes
 export BOOTSTRAP_HASKELL_GHC_VERSION=$GHC_VERSION
 export BOOTSTRAP_HASKELL_CABAL_VERSION=$CABAL_VERSION
 
-./bootstrap-haskell
+./scripts/bootstrap/bootstrap-haskell
 
 [ "$(ghc --numeric-version)" = "${GHC_VERSION}" ]
 

.gitlab/script/ghcup_cross.sh

@@ -13,7 +13,7 @@ ecabal() {
 }
 
 eghcup() {
-	ghcup -v -c -s file://$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
+	ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
 }
 
 git describe --always

.gitlab/script/ghcup_git.sh

@@ -13,7 +13,7 @@ ecabal() {
 }
 
 eghcup() {
-	ghcup -v -c -s file://$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
+	ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
 }
 
 git describe --always

.gitlab/script/ghcup_hls.sh

@@ -0,0 +1,51 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+CI_PROJECT_DIR=$(pwd)
+
+ecabal() {
+	cabal "$@"
+}
+
+eghcup() {
+	ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
+}
+
+git describe --always
+
+### build
+
+ecabal update
+
+ecabal build -w ghc-${GHC_VERSION}
+cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" "$CI_PROJECT_DIR"/.local/bin/ghcup
+
+### cleanup
+
+rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
+
+### manual cli based testing
+
+eghcup --numeric-version
+
+eghcup install ghc ${GHC_VERSION}
+eghcup set ghc ${GHC_VERSION}
+eghcup install cabal ${CABAL_VERSION}
+
+cabal --version
+
+eghcup debug-info
+
+eghcup compile hls -j $(nproc) -v ${HLS_TARGET_VERSION} ${GHC_VERSION}
+
+[ `$(eghcup whereis hls ${HLS_TARGET_VERSION}) --numeric-version` = "${HLS_TARGET_VERSION}" ] || [ `$(eghcup whereis hls ${HLS_TARGET_VERSION}) --numeric-version | sed 's/.0$//'` = "${HLS_TARGET_VERSION}" ]
+
+# nuke
+eghcup nuke
+[ ! -e "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup" ]
+

.gitlab/script/ghcup_release.sh

@@ -18,7 +18,7 @@ ecabal update
 
 if [ "${OS}" = "LINUX" ] ; then
 	if [ "${ARCH}" = "32" ] ; then
-		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui -ftar
+		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
 	elif [ "${ARCH}" = "64" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
 	else

.gitlab/script/ghcup_version.sh

@@ -18,9 +18,9 @@ raw_eghcup() {
 
 eghcup() {
 	if [ "${OS}" = "WINDOWS" ] ; then
-		ghcup -v -c -s file:/$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
+		ghcup -v -c -s file:/$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
 	else
-		ghcup -v -c -s file://$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
+		ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
 	fi
 }
 
@@ -42,22 +42,25 @@ if [ "${OS}" = "DARWIN" ] ; then
 	ecabal haddock -w ghc-${GHC_VERSION} -ftui
 elif [ "${OS}" = "LINUX" ] ; then
 	if [ "${ARCH}" = "32" ] ; then
-		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
+		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
-		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar ghcup-test
+		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
-		ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
+		ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui
 	else
 		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
 		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
 		ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui
 
-		# doctest
+		if [ "${ARCH}" = "64" ] ; then
-		curl -sL https://github.com/phadej/cabal-extras/releases/download/cabal-docspec-0.0.0.20210111/cabal-docspec-0.0.0.20210111.xz > cabal-docspec.xz
+			# doctest
-		echo '0829bd034fba901cbcfe491d98ed8b28fd54f9cb5c91fa8e1ac62dc4413c9562  cabal-docspec.xz' | sha256sum -c -
+			curl -sL https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal-docspec/cabal-docspec-0.0.0.20210228_p1.tar.bz2 > cabal-docspec.tar.bz2
-		xz -d < cabal-docspec.xz > "$CI_PROJECT_DIR"/.local/bin/cabal-docspec
+			echo '3a10f6fec16dbd18efdd331b1cef5d2d342082da42f5b520726d1fa6a3990d12  cabal-docspec.tar.bz2' | sha256sum -c -
-		rm -f cabal-docspec.xz
+			tar -xjf cabal-docspec.tar.bz2 cabal-docspec
-		chmod a+x "$CI_PROJECT_DIR"/.local/bin/cabal-docspec
+			mv cabal-docspec "$CI_PROJECT_DIR"/.local/bin/cabal-docspec
+			rm -f cabal-docspec.tar.bz2
+			chmod a+x "$CI_PROJECT_DIR"/.local/bin/cabal-docspec
 
-		cabal-docspec -XCPP -XTypeSynonymInstances -XOverloadedStrings -XPackageImports --check-properties
+			cabal-docspec -XCPP -XTypeSynonymInstances -XOverloadedStrings -XPackageImports --check-properties
+		fi
 	fi
 elif [ "${OS}" = "FREEBSD" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui --constraint="zip +disable-zstd"
@@ -89,7 +92,7 @@ rm -rf "${GHCUP_DIR}"
 ### manual cli based testing
 
 
-ghcup-gen check -f ghcup-${JSON_VERSION}.yaml
+ghcup-gen check -f data/metadata/ghcup-${JSON_VERSION}.yaml
 
 eghcup --numeric-version
 
@@ -98,6 +101,10 @@ eghcup install ghc ${GHC_VERSION}
 eghcup set ghc ${GHC_VERSION}
 eghcup install cabal ${CABAL_VERSION}
 [ `$(eghcup whereis cabal ${CABAL_VERSION}) --numeric-version` = "${CABAL_VERSION}" ]
+eghcup unset cabal
+"$GHCUP_BIN"/cabal --version && exit || echo yes
+eghcup set cabal ${CABAL_VERSION}
+[ `$(eghcup whereis cabal ${CABAL_VERSION}) --numeric-version` = "${CABAL_VERSION}" ]
 
 cabal --version
 
@@ -148,9 +155,13 @@ else
 	[ "$(ghc --numeric-version)" = "8.10.3" ]
 	eghcup set ${GHC_VERSION}
 	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
+	eghcup unset ghc
+    "$GHCUP_BIN"/ghc --numeric-version && exit || echo yes
+	eghcup set ${GHC_VERSION}
 	eghcup --offline rm 8.10.3
 	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
 
+
 	if [ "${OS}" = "DARWIN" ] ; then
 		eghcup install hls
 		$(eghcup whereis hls) --version
@@ -161,18 +172,22 @@ else
 		if [ "${ARCH}" = "64" ] ; then
 			eghcup install hls
 			haskell-language-server-wrapper --version
+			eghcup unset hls
+			"$GHCUP_BIN"/haskell-language-server-wrapper --version && exit || echo yes
 
 			eghcup install stack
 			stack --version
+			eghcup unset hls
+			"$GHCUP_BIN"/stack --version && exit || echo yes
 		fi
 	fi
 fi
 
 # check that lazy loading works for 'whereis'
-cp "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml" "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml.bak"
+cp "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml" "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml.bak"
-echo '**' > "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml"
+echo '**' > "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml"
 eghcup whereis ghc $(ghc --numeric-version)
-mv -f "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml.bak" "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml"
+mv -f "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml.bak" "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml"
 
 eghcup rm $(ghc --numeric-version)
 

README.md

@@ -10,20 +10,23 @@ Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [p
 [![Join the chat at Matrix.org](https://img.shields.io/matrix/haskell-tooling:matrix.org?label=chat%20on%20matrix.org)](https://app.element.io/#/room/#haskell-tooling:matrix.org)
 [![Join the chat at Discord](https://img.shields.io/discord/280033776820813825?label=chat%20on%20discord)](https://discord.gg/pKYf3zDQU7)
 [![Join the chat at https://gitter.im/haskell/ghcup](https://badges.gitter.im/haskell/ghcup.svg)](https://gitter.im/haskell/ghcup?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+<a href="https://opencollective.com/ghcup#category-CONTRIBUTE"><img src="https://opencollective.com/webpack/donate/button@2x.png?color=blue" alt="Donate" width="150"></a>
 
    * [Installation](#installation)
-     * [Simple bootstrap](#simple-bootstrap)
+     * [Supported platforms](#supported-platforms)
      * [Manual install](#manual-install)
      * [Vim integration](#vim-integration)
    * [Usage](#usage)
      * [Configuration](#configuration)
+     * [GPG verification](#gpg-verification)
      * [Manpages](#manpages)
      * [Shell-completion](#shell-completion)
-     * [Cross support](#cross-support)
+     * [Compiling GHC from source](#compiling-ghc-from-source)
      * [XDG support](#xdg-support)
      * [Env variables](#env-variables)
      * [Installing custom bindists](#installing-custom-bindists)
      * [Isolated Installs](#isolated-installs)
+     * [CI](#ci)
      * [Tips and tricks](#tips-and-tricks)
    * [Design goals](#design-goals)
    * [How](#how)
@@ -33,9 +36,59 @@ Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [p
 
 ## Installation
 
-### Simple bootstrap
+Most users should follow the instructions at [https://www.haskell.org/ghcup/](https://www.haskell.org/ghcup/).
+Advanced users may want to perform a [manual installation](#manual-install).
 
-Follow the instructions at [https://www.haskell.org/ghcup/](https://www.haskell.org/ghcup/)
+### Supported platforms
+
+This list may not be exhaustive and specifies support for bindists only.
+
+| Platform | Architecture | ghcup | GHC | cabal | HLS | stack | 
+| ------ | ------ | ------ | ------ | ------ | ------ | ------ |
+| Windows 7 | amd64 | ❔ | ✅ | ✅ | ✅ | ✅ |
+| Windows 10 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Windows Server 2016 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Windows Server 2019 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Windows Server 2022 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Windows WSL1 | amd64 | ❌ | ❔ | ❔ | ❔ | ❔ |
+| Windows WSL2 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
+| MacOS >=13 | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
+| MacOS <13 | amd64 | ❌ | ❔ | ❔ | ❔ | ❔ |
+| MacOS | aarch64 | ✅ | ✅ | ✅ | ⚠️ | ❌ |
+| FreeBSD | amd64 | ✅ | ⚠️ | ✅ | ⚠️ | ❌ |
+| Linux generic | x86 | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Linux generic | amd64 | ✅ | ✅ | ✅ | ✅ | ✅ |
+| Linux generic | aarch64 | ✅ | ⚠️ | ✅ | ⚠️ | ❌ |
+| Linux generic | armv7 | ✅ | ⚠️ | ✅ | ⚠️ | ❌ |
+
+#### Windows 7
+
+May or may not work, several issues:
+
+* https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/140
+* https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/197
+
+#### WSL1
+
+Unsupported. GHC may or may not work. Upgrade to WSL2.
+
+#### MacOS <13
+
+Not supported. Would require separate binaries, since >=13 binaries are incompatible.
+Please upgrade.
+
+#### MacOS aarch64
+
+HLS bindists are still experimental. Stack is theoretically supported, but has no binaries yet.
+
+#### FreeBSD
+
+Lacks some upstream bindists and may need compat libs, since most bindists are built on FreeBSD-12.
+HLS bindists are experimental.
+
+#### Linux ARMv7/AARCH64
+
+Lower availability of bindists. HLS only has experimental ones. Stack not supported currently.
 
 ### Manual install
 
@@ -90,10 +143,38 @@ handles your haskell packages and can demand that [a specific version](https://c
 ### Configuration
 
 A configuration file can be put in `~/.ghcup/config.yaml`. The default config file
-explaining all possible configurations can be found in this repo: [config.yaml](./config.yaml).
+explaining all possible configurations can be found in this repo: [config.yaml](./data/config.yaml).
 
 Partial configuration is fine. Command line options always override the config file settings.
 
+### GPG verification
+
+GHCup supports verifying the GPG signature of the metadata file. The metadata file then contains SHA256 hashes of all downloads, so
+this is cryptographically secure.
+
+First, obtain the gpg key:
+
+```sh
+gpg --batch --keyserver keys.openpgp.org --recv-keys 7784930957807690A66EBDBE3786C5262ECB4A3F
+```
+
+Then verify the gpg key in one of these ways:
+
+1. find out where I live and visit me to do offline key signing
+2. figure out my mobile phone number and call me to verify the fingerprint
+3. more boring: contact me on Libera IRC (`maerwald`) and verify the fingerprint
+
+Once you've verified the key, you have to figure out if you trust me.
+
+If you trust me, then you can configure gpg in `~/.ghcup/config.yaml`:
+
+```yml
+gpg-setting: GPGLax # GPGStrict | GPGLax | GPGNone
+```
+
+In `GPGStrict` mode, ghcup will fail if verification fails. In `GPGLax` mode it will just print a warning.
+You can also pass the mode via `ghcup --gpg <strict|lax|none>`.
+
 ### Manpages
 
 For man pages to work you need [man-db](http://man-db.nongnu.org/) as your `man` provider, then issue `man ghc`. Manpages only work for the currently set ghc.
@@ -101,14 +182,26 @@ For man pages to work you need [man-db](http://man-db.nongnu.org/) as your `man`
 
 ### Shell-completion
 
-Shell completions are in `shell-completions`.
+Shell completions are in [scripts/shell-completions](./scripts/shell-completions) directory of this repository.
 
 For bash: install `shell-completions/bash`
 as e.g. `/etc/bash_completion.d/ghcup` (depending on distro)
 and make sure your bashrc sources the startup script
 (`/usr/share/bash-completion/bash_completion` on some distros).
 
-### Cross support
+### Compiling GHC from source
+
+Compiling from source is supported for both source tarballs and arbitrary git refs. See `ghcup compile ghc --help`
+for a list of all available options.
+
+If you need to overwrite the existing `build.mk`, check the default files
+in [data/build_mk](./data/build_mk), copy them somewhere, adjust them and
+pass `--config path/to/build.mk` to `ghcup compile ghc`.
+Common `build.mk` options are explained [here](https://gitlab.haskell.org/ghc/ghc/-/wikis/building/using#build-configuration).
+
+Make sure your system meets all the [prerequisites](https://gitlab.haskell.org/ghc/ghc/-/wikis/building/preparation).
+
+#### Cross support
 
 ghcup can compile and install a cross GHC for any target. However, this
 requires that the build host has a complete cross toolchain and various
@@ -142,6 +235,7 @@ This is the complete list of env variables that change GHCup behavior:
 * `GHCUP_INSTALL_BASE_PREFIX`: the base of ghcup (default: `$HOME`)
 * `GHCUP_CURL_OPTS`: additional options that can be passed to curl
 * `GHCUP_WGET_OPTS`: additional options that can be passed to wget
+* `GHCUP_GPG_OPTS`: additional options that can be passed to gpg
 * `GHCUP_SKIP_UPDATE_CHECK`: Skip the (possibly annoying) update check when you run a command
 * `CC`/`LD` etc.: full environment is passed to the build system when compiling GHC via GHCup
 
@@ -190,6 +284,83 @@ Examples:-
 5. you can even compile ghc to an isolated location.  
    - `ghcup compile ghc -j 4 -v 9.0.1 -b 8.10.5 -i /home/username/my/dir/ghc` 
    ---  
+
+### CI
+
+On windows, ghcup can be installed automatically on a CI runner like so:
+
+```ps
+Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $false,$true,$true,$false,$false,$false,$false,"C:\"
+```
+
+On linux/darwin/freebsd, run the following on your runner:
+
+```sh
+curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 BOOTSTRAP_HASKELL_MINIMAL=1 sh
+```
+
+This will just install `ghcup` and on windows additionally `msys2`.
+
+#### Example github workflow
+
+On github workflows you can use https://github.com/haskell/actions/
+
+If you want to install ghcup manually though, here's an example config:
+
+```yml
+name: Haskell CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build-cabal:
+
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macOS-latest, windows-latest]
+        ghc: ['8.10.7', '9.0.1']
+        cabal: ['3.4.0.0']
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - if: matrix.os == 'windows-latest'
+      name: Install ghcup on windows
+      run: Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $false,$true,$true,$false,$false,$false,$false,"C:\"
+
+    - if: matrix.os == 'windows-latest'
+      name: Add ghcup to PATH
+      run: echo "/c/ghcup/bin" >> $GITHUB_PATH
+      shell: bash
+
+    - if: matrix.os != 'windows-latest'
+      name: Install ghcup on non-windows
+      run: curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 BOOTSTRAP_HASKELL_MINIMAL=1 sh
+
+    - name: Install ghc/cabal
+      run: |
+        ghcup install ghc ${{ matrix.ghc }}
+        ghcup install cabal ${{ matrix.cabal }}
+      shell: bash
+
+    - name: Update cabal index
+      run: cabal update
+      shell: bash
+
+    - name: Build
+      run: cabal build --enable-tests --enable-benchmarks
+      shell: bash
+
+    - name: Run tests
+      run: cabal test
+      shell: bash
+```
    
 ### Tips and tricks
 
@@ -266,8 +437,13 @@ In addition this script can also install `cabal-install`.
 
 ## Known users
 
-* Github action [haskell/actions/setup](https://github.com/haskell/actions/tree/main/setup)
+* Github actions:
-* [vabal](https://github.com/Franciman/vabal)
+	- [actions/virtual-environments](https://github.com/actions/virtual-environments)
+	- [haskell/actions/setup](https://github.com/haskell/actions/tree/main/setup)
+* mirrors:
+	- [sjtug](https://mirror.sjtu.edu.cn/docs/ghcup)
+* tools:
+	- [vabal](https://github.com/Franciman/vabal)
 
 ## Known problems
 

RELEASING.md

@@ -1,19 +0,0 @@
-# RELEASING
-
-1. update `GHCup.Version` module. `ghcupURL` must only be updated if we change the `_toolRequirements` type or the YAML representation of it. The version of the YAML represents the change increments. `ghcUpVer` is the current application version.
-
-2. Update version in ghcup.cabal
-
-3. Add ChangeLog entry
-
-4. Add/fix downloads in `ghcup-<ver>.yaml`, then verify with `ghcup-gen check -f ghcup-<ver>.yaml`
-
-5. Commit and git push with tag. Wait for tests to succeed and release artifacts to build.
-
-6. Download release artifacts and upload them `downloads.haskell.org/ghcup`
-
-7. Add release artifacts to yaml file (see point 4.)
-
-8. Upload the final `ghcup-<ver>.yaml` to `webhost.haskell.org/ghcup/data/`.
-
-9. Update bootstrap-haskell and symlinks on `downloads.haskell.org/ghcup`

app/ghcup-gen/Main.hs

@@ -11,22 +11,33 @@
 module Main where
 
 import           GHCup.Types
-import           GHCup.Types.JSON               ( )
+import           GHCup.Errors
+import           GHCup.Platform
+import           GHCup.Utils.Dirs
 import           GHCup.Utils.Logger
+import           GHCup.Types.JSON               ( )
 
+import           Control.Monad.Trans.Reader     ( runReaderT )
+import           Control.Monad.IO.Class
 import           Data.Char                      ( toLower )
+import           Data.Maybe
 #if !MIN_VERSION_base(4,13,0)
 import           Data.Semigroup                 ( (<>) )
 #endif
 import           Options.Applicative     hiding ( style )
+import           Haskus.Utils.Variant.Excepts
 import           System.Console.Pretty
+import           System.Environment
 import           System.Exit
-import           System.IO                      ( stdout )
+import           System.IO                      ( stderr )
 import           Text.Regex.Posix
 import           Validate
+import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 
+import qualified Data.Text.IO                  as T
+import qualified Data.Text                     as T
 import qualified Data.ByteString               as B
-import qualified Data.Yaml                     as Y
+import qualified Data.YAML.Aeson               as Y
 
 
 data Options = Options
@@ -105,10 +116,29 @@ com = subparser
 
 main :: IO ()
 main = do
+  no_color <- isJust <$> lookupEnv "NO_COLOR"
+  let loggerConfig = LoggerConfig { lcPrintDebug  = True
+                                  , consoleOutter = T.hPutStr stderr
+                                  , fileOutter    = \_ -> pure ()
+                                  , fancyColors   = not no_color
+                                  }
+  dirs <- liftIO getAllDirs
+  let leanAppstate = LeanAppState (Settings True False Never Curl True GHCupURL False GPGNone) dirs defaultKeyBindings loggerConfig
+
+  pfreq <- (
+    flip runReaderT leanAppstate . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound] $ platformRequest
+    ) >>= \case
+            VRight r -> pure r
+            VLeft e -> do
+              flip runReaderT leanAppstate $ logError $ T.pack $ prettyShow e
+              liftIO $ exitWith (ExitFailure 2)
+
+  let appstate = AppState (Settings True False Never Curl True GHCupURL False GPGNone) dirs defaultKeyBindings (GHCupInfo mempty mempty mempty) pfreq loggerConfig
+
   _ <- customExecParser (prefs showHelpOnError) (info (opts <**> helper) idm)
     >>= \Options {..} -> case optCommand of
-          ValidateYAML vopts -> withValidateYamlOpts vopts validate
+          ValidateYAML vopts -> withValidateYamlOpts vopts (\dl m -> flip runReaderT appstate $ validate dl m)
-          ValidateTarballs vopts tarballFilter -> withValidateYamlOpts vopts (validateTarballs tarballFilter)
+          ValidateTarballs vopts tarballFilter -> withValidateYamlOpts vopts (\dl m -> flip runReaderT appstate $ validateTarballs tarballFilter dl m)
   pure ()
 
  where
@@ -120,8 +150,8 @@ main = do
     ValidateYAMLOpts { vInput = Just (FileInput file) } ->
       B.readFile file >>= valAndExit f
   valAndExit f contents = do
-    (GHCupInfo _ av gt) <- case Y.decodeEither' contents of
+    (GHCupInfo _ av gt) <- case Y.decode1Strict contents of
       Right r -> pure r
-      Left  e -> die (color Red $ show e)
+      Left  (_, e) -> die (color Red $ show e)
-    myLoggerT (LoggerConfig True (B.hPut stdout) (\_ -> pure ())) (f av gt)
+    f av gt
       >>= exitWith

app/ghcup-gen/Validate.hs

@@ -5,29 +5,24 @@
 {-# LANGUAGE TemplateHaskell  #-}
 {-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE ViewPatterns     #-}
+{-# LANGUAGE OverloadedStrings #-}
 
 module Validate where
 
 import           GHCup
 import           GHCup.Download
 import           GHCup.Errors
-import           GHCup.Platform
+import           GHCup.Types
-import           GHCup.Types                  hiding ( LeanAppState (..) )
 import           GHCup.Types.Optics
 import           GHCup.Utils
 import           GHCup.Utils.Logger
 import           GHCup.Utils.Version.QQ
 
-#if defined(TAR)
-import qualified Codec.Archive.Tar             as Tar
-#else
 import           Codec.Archive
-#endif
 import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Class
-import           Control.Monad.Logger
 import           Control.Monad.Reader.Class
 import           Control.Monad.Trans.Class      ( lift )
 import           Control.Monad.Trans.Reader     ( runReaderT )
@@ -37,18 +32,15 @@ import           Control.Monad.Trans.Resource   ( runResourceT
 import           Data.Containers.ListUtils      ( nubOrd )
 import           Data.IORef
 import           Data.List
-import           Data.String.Interpolate
 import           Data.Versions
 import           Haskus.Utils.Variant.Excepts
 import           Optics
 import           System.FilePath
 import           System.Exit
-import           System.IO
 import           Text.ParserCombinators.ReadP
 import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           Text.Regex.Posix
 
-import qualified Data.ByteString               as B
 import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 import qualified Data.Version                  as V
@@ -66,7 +58,7 @@ addError = do
   liftIO $ modifyIORef ref (+ 1)
 
 
-validate :: (Monad m, MonadLogger m, MonadThrow m, MonadIO m, MonadUnliftIO m)
+validate :: (Monad m, MonadReader env m, HasLog env, MonadThrow m, MonadIO m, MonadUnliftIO m)
          => GHCupDownloads
          -> M.Map GlobalTool DownloadInfo
          -> m ExitCode
@@ -93,24 +85,23 @@ validate dls _ = do
     if e > 0
       then pure $ ExitFailure e
       else do
-        lift $ $(logInfo) [i|All good|]
+        lift $ logInfo "All good"
         pure ExitSuccess
  where
   checkHasRequiredPlatforms t v tags arch pspecs = do
     let v' = prettyVer v
         arch' = prettyShow arch
     when (notElem (Linux UnknownLinux) pspecs) $ do
-      lift $ $(logError)
+      lift $ logError $
-        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch'}|]
+        "Linux UnknownLinux missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
       addError
     when ((notElem Darwin pspecs) && arch == A_64) $ do
-      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch'}|]
+      lift $ logError $ "Darwin missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
       addError
-    when ((notElem FreeBSD pspecs) && arch == A_64) $ lift $ $(logWarn)
+    when ((notElem FreeBSD pspecs) && arch == A_64) $ lift $ logWarn $
-      [i|FreeBSD missing for #{t} #{v'} #{arch'}|]
+      "FreeBSD missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
     when (notElem Windows pspecs && arch == A_64) $ do
-      lift $ $(logError)
+      lift $ logError $ "Windows missing for for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack arch'
-        [i|Windows missing for for #{t} #{v'} #{arch'}|]
       addError
 
     -- alpine needs to be set explicitly, because
@@ -118,12 +109,12 @@ validate dls _ = do
     -- (although it could be static)
     when (notElem (Linux Alpine) pspecs) $
       case t of
-        GHCup | arch `elem` [A_64, A_32] -> lift ($(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
+        GHCup | arch `elem` [A_64, A_32] -> lift (logError $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch)) >> addError
         Cabal | v > [vver|2.4.1.0|]
-              , arch `elem` [A_64, A_32] -> lift ($(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]) >> addError
+              , arch `elem` [A_64, A_32] -> lift (logError $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch)) >> addError
         GHC | Latest `elem` tags || Recommended `elem` tags
-            , arch `elem` [A_64, A_32] -> lift ($(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|])
+            , arch `elem` [A_64, A_32] -> lift (logError $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch))
-        _ -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]
+        _ -> lift $ logWarn $ "Linux Alpine missing for " <> T.pack (prettyShow t) <> " " <> v' <> " " <> T.pack (prettyShow arch)
 
   checkUniqueTags tool = do
     let allTags = join $ fmap _viTags $ M.elems $ availableToolVersions dls tool
@@ -143,7 +134,7 @@ validate dls _ = do
     case join nonUnique of
       [] -> pure ()
       xs -> do
-        lift $ $(logError) [i|Tags not unique for #{tool}: #{xs}|]
+        lift $ logError $ "Tags not unique for " <> T.pack (prettyShow tool) <> ": " <> T.pack (prettyShow xs)
         addError
    where
     isUniqueTag Latest         = True
@@ -159,7 +150,7 @@ validate dls _ = do
       case [ x | (x,"") <- readP_to_S V.parseVersion (T.unpack . prettyVer $ v) ] of
         [_] -> pure ()
         _   -> do
-          lift $ $(logError) [i|GHC version #{v} is not valid |]
+          lift $ logError $ "GHC version " <> prettyVer v <> " is not valid"
           addError
 
   -- a tool must have at least one of each mandatory tags
@@ -167,7 +158,7 @@ validate dls _ = do
     let allTags = join $ fmap _viTags $ M.elems $ availableToolVersions dls tool
     forM_ [Latest, Recommended] $ \t -> case elem t allTags of
       False -> do
-        lift $ $(logError) [i|Tag #{t} missing from #{tool}|]
+        lift $ logError $ "Tag " <> T.pack (prettyShow t) <> " missing from " <> T.pack (prettyShow tool)
         addError
       True -> pure ()
 
@@ -176,7 +167,7 @@ validate dls _ = do
     let allTags = M.toList $ availableToolVersions dls GHC
     forM allTags $ \(ver, _viTags -> tags) -> case any isBase tags of
       False -> do
-        lift $ $(logError) [i|Base tag missing from GHC ver #{ver}|]
+        lift $ logError $ "Base tag missing from GHC ver " <> prettyVer ver
         addError
       True -> pure ()
 
@@ -189,7 +180,10 @@ data TarballFilter = TarballFilter
   }
 
 validateTarballs :: ( Monad m
-                    , MonadLogger m
+                    , MonadReader env m
+                    , HasLog env
+                    , HasDirs env
+                    , HasSettings env
                     , MonadThrow m
                     , MonadIO m
                     , MonadUnliftIO m
@@ -204,59 +198,48 @@ validateTarballs :: ( Monad m
 validateTarballs (TarballFilter etool versionRegex) dls gt = do
   ref <- liftIO $ newIORef 0
 
-  flip runReaderT ref $ do
+   -- download/verify all tarballs
-     -- download/verify all tarballs
+  let dlis = either (const []) (\tool -> nubOrd $ dls ^.. each %& indices (maybe (const True) (==) tool) %> each %& indices (matchTest versionRegex . T.unpack . prettyVer) % (viSourceDL % _Just `summing` viArch % each % each % each)) etool
-    let dlis = either (const []) (\tool -> nubOrd $ dls ^.. each %& indices (maybe (const True) (==) tool) %> each %& indices (matchTest versionRegex . T.unpack . prettyVer) % (viSourceDL % _Just `summing` viArch % each % each % each)) etool
+  let gdlis = nubOrd $ gt ^.. each
-    let gdlis = nubOrd $ gt ^.. each
+  let allDls = either (const gdlis) (const dlis) etool
-    let allDls = either (const gdlis) (const dlis) etool
+  when (null allDls) $ logError "no tarballs selected by filter" *> (flip runReaderT ref addError)
-    when (null allDls) $ $(logError) [i|no tarballs selected by filter|] *> addError
+  forM_ allDls (downloadAll ref)
-    forM_ allDls downloadAll
 
-    -- exit
+  -- exit
-    e <- liftIO $ readIORef ref
+  e <- liftIO $ readIORef ref
-    if e > 0
+  if e > 0
-      then pure $ ExitFailure e
+    then pure $ ExitFailure e
-      else do
+    else do
-        lift $ $(logInfo) [i|All good|]
+      logInfo "All good"
-        pure ExitSuccess
+      pure ExitSuccess
 
  where
-  runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
+  downloadAll :: ( MonadUnliftIO m
-                                     , colorOutter  = B.hPut stderr
+                 , MonadIO m
-                                     , rawOutter    = \_ -> pure ()
+                 , MonadReader env m
-                                     }
+                 , HasLog env
-  downloadAll dli = do
+                 , HasDirs env
-    dirs <- liftIO getAllDirs
+                 , HasSettings env
-
+                 , MonadCatch m
-    pfreq <- (
+                 , MonadMask m
-      runLogger . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound] . liftE $ platformRequest
+                 , MonadThrow m
-      ) >>= \case
+                 )
-              VRight r -> pure r
+              => IORef Int
-              VLeft e -> do
+              -> DownloadInfo
-                lift $ runLogger
+              -> m ()
-                  ($(logError) $ T.pack $ prettyShow e)
+  downloadAll ref dli = do
-                liftIO $ exitWith (ExitFailure 2)
+    r <- runResourceT
-
-    let appstate = AppState (Settings True False Never Curl True GHCupURL False) dirs defaultKeyBindings (GHCupInfo mempty mempty mempty) pfreq
-
-    r <-
-      runLogger
-      . flip runReaderT appstate
-      . runResourceT
       . runE @'[DigestError
+               , GPGError
                , DownloadFailed
                , UnknownArchive
-#if defined(TAR)
-               , Tar.FormatError
-#else
                , ArchiveResult
-#endif
                ]
       $ do
         case etool of
           Right (Just GHCup) -> do
             tmpUnpack <- lift mkGhcupTmpDir
-            _ <- liftE $ download (_dlUri dli) (Just (_dlHash dli)) tmpUnpack Nothing False
+            _ <- liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) tmpUnpack Nothing False
             pure Nothing
           Right _ -> do
             p <- liftE $ downloadCached dli Nothing
@@ -266,32 +249,32 @@ validateTarballs (TarballFilter etool versionRegex) dls gt = do
               $ p
           Left ShimGen -> do
             tmpUnpack <- lift mkGhcupTmpDir
-            _ <- liftE $ download (_dlUri dli) (Just (_dlHash dli)) tmpUnpack Nothing False
+            _ <- liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) tmpUnpack Nothing False
             pure Nothing
     case r of
       VRight (Just basePath) -> do
         case _dlSubdir dli of
           Just (RealDir prel) -> do
-            lift $ $(logInfo)
+            logInfo
-              [i|verifying subdir: #{prel}|]
+              $ " verifying subdir: " <> T.pack prel
             when (basePath /= prel) $ do
-              lift $ $(logError)
+              logError $
-                [i|Subdir doesn't match: expected "#{prel}", got "#{basePath}"|]
+                "Subdir doesn't match: expected " <> T.pack prel <> ", got " <> T.pack basePath
-              addError
+              (flip runReaderT ref addError)
           Just (RegexDir regexString) -> do
-            lift $ $(logInfo)
+            logInfo $
-              [i|verifying subdir (regex): #{regexString}|]
+              "verifying subdir (regex): " <> T.pack regexString
             let regex = makeRegexOpts
                   compIgnoreCase
                   execBlank
                   regexString
             when (not (match regex basePath)) $ do
-              lift $ $(logError)
+              logError $
-                [i|Subdir doesn't match: expected regex "#{regexString}", got "#{basePath}"|]
+                "Subdir doesn't match: expected regex " <> T.pack regexString <> ", got " <> T.pack basePath
-              addError
+              (flip runReaderT ref addError)
           Nothing -> pure ()
       VRight Nothing -> pure ()
       VLeft  e -> do
-        lift $ $(logError)
+        logError $
-          [i|Could not download (or verify hash) of #{dli}, Error was: #{prettyShow e}|]
+          "Could not download (or verify hash) of " <> T.pack (show dli) <> ", Error was: " <> T.pack (prettyShow e)
-        addError
+        (flip runReaderT ref addError)

app/ghcup/BrickMain.hs

@@ -15,9 +15,9 @@ import           GHCup.Download
 import           GHCup.Errors
 import           GHCup.Types         hiding ( LeanAppState(..) )
 import           GHCup.Utils
+import           GHCup.Utils.Logger
 import           GHCup.Utils.Prelude ( decUTF8Safe )
 import           GHCup.Utils.File
-import           GHCup.Utils.Logger
 
 import           Brick
 import           Brick.Widgets.Border
@@ -27,11 +27,8 @@ import           Brick.Widgets.List             ( listSelectedFocusedAttr
                                                 , listSelectedAttr
                                                 , listAttr
                                                 )
-#if !defined(TAR)
 import           Codec.Archive
-#endif
 import           Control.Exception.Safe
-import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Except
 import           Control.Monad.Trans.Resource
@@ -40,7 +37,6 @@ import           Data.Functor
 import           Data.List
 import           Data.Maybe
 import           Data.IORef
-import           Data.String.Interpolate
 import           Data.Vector                    ( Vector
                                                 , (!?)
                                                 )
@@ -420,17 +416,11 @@ install' :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadFail m, Monad
 install' _ (_, ListResult {..}) = do
   AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
 
-  l        <- liftIO $ readIORef logger'
-  let runLogger = myLoggerT l
-
   let run =
-        runLogger
+        runResourceT
-          . runResourceT
           . runE
             @'[ AlreadyInstalled
-#if !defined(TAR)
               , ArchiveResult
-#endif
               , UnknownArchive
               , FileDoesNotExistError
               , CopyError
@@ -439,6 +429,7 @@ install' _ (_, ListResult {..}) = do
               , BuildFailed
               , TagNotFound
               , DigestError
+              , GPGError
               , DownloadFailed
               , DirNotEmpty
               , NoUpdate
@@ -450,40 +441,37 @@ install' _ (_, ListResult {..}) = do
       case lTool of
         GHC   -> do
           let vi = getVersionInfo lVer GHC dls
-          liftE $ installGHCBin lVer Nothing $> vi
+          liftE $ installGHCBin lVer Nothing False $> vi
         Cabal -> do
           let vi = getVersionInfo lVer Cabal dls
-          liftE $ installCabalBin lVer Nothing $> vi
+          liftE $ installCabalBin lVer Nothing False $> vi
         GHCup -> do
           let vi = snd <$> getLatest dls GHCup
           liftE $ upgradeGHCup Nothing False $> vi
         HLS   -> do
           let vi = getVersionInfo lVer HLS dls
-          liftE $ installHLSBin lVer Nothing $> vi
+          liftE $ installHLSBin lVer Nothing False $> vi
         Stack -> do
           let vi = getVersionInfo lVer Stack dls
-          liftE $ installStackBin lVer Nothing $> vi
+          liftE $ installStackBin lVer Nothing False $> vi
     )
     >>= \case
           VRight vi                         -> do
             forM_ (_viPostInstall =<< vi) $ \msg ->
-              myLoggerT l $ $(logInfo) msg
+              logInfo msg
             pure $ Right ()
           VLeft  (V (AlreadyInstalled _ _)) -> pure $ Right ()
           VLeft (V NoUpdate) -> pure $ Right ()
-          VLeft e -> pure $ Left [i|#{prettyShow e}
+          VLeft e -> pure $ Left $ prettyShow e <> "\n"
-Also check the logs in ~/.ghcup/logs|]
+            <> "Also check the logs in ~/.ghcup/logs"
 
 
 set' :: BrickState -> (Int, ListResult) -> IO (Either String ())
 set' _ (_, ListResult {..}) = do
   settings <- readIORef settings'
-  l        <- readIORef logger'
-  let runLogger = myLoggerT l
 
   let run =
-        runLogger
+        flip runReaderT settings
-          . flip runReaderT settings
           . runE @'[FileDoesNotExistError , NotInstalled , TagNotFound]
 
   run (do
@@ -506,9 +494,7 @@ del' :: (MonadReader AppState m, MonadIO m, MonadFail m, MonadMask m, MonadUnlif
 del' _ (_, ListResult {..}) = do
   AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
 
-  l <- liftIO $ readIORef logger'
+  let run = runE @'[NotInstalled]
-  let runLogger = myLoggerT l
-  let run = myLoggerT l . runE @'[NotInstalled]
 
   run (do
       let vi = getVersionInfo lVer lTool dls
@@ -522,7 +508,7 @@ del' _ (_, ListResult {..}) = do
     >>= \case
           VRight vi -> do
             forM_ (join $ fmap _viPostRemove vi) $ \msg ->
-              runLogger $ $(logInfo) msg
+              logInfo msg
             pure $ Right ()
           VLeft  e -> pure $ Left (prettyShow e)
 
@@ -534,8 +520,8 @@ changelog' :: (MonadReader AppState m, MonadIO m)
 changelog' _ (_, ListResult {..}) = do
   AppState { pfreq, ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
   case getChangeLog dls lTool (Left lVer) of
-    Nothing -> pure $ Left
+    Nothing -> pure $ Left $
-      [i|Could not find ChangeLog for #{lTool}, version #{prettyVer lVer}|]
+      "Could not find ChangeLog for " <> prettyShow lTool <> ", version " <> T.unpack (prettyVer lVer)
     Just uri -> do
       let cmd = case _rPlatform pfreq of
             Darwin  -> "open"
@@ -551,6 +537,11 @@ settings' :: IORef AppState
 {-# NOINLINE settings' #-}
 settings' = unsafePerformIO $ do
   dirs <- getAllDirs
+  let loggerConfig = LoggerConfig { lcPrintDebug  = False
+                                  , consoleOutter = \_ -> pure ()
+                                  , fileOutter    = \_ -> pure ()
+                                  , fancyColors   = True
+                                  }
   newIORef $ AppState (Settings { cache      = True
                                 , noVerify   = False
                                 , keepDirs   = Never
@@ -558,33 +549,21 @@ settings' = unsafePerformIO $ do
                                 , verbose    = False
                                 , urlSource  = GHCupURL
                                 , noNetwork  = False
+                                , gpgSetting = GPGNone
                                 , ..
                                 })
                       dirs
                       defaultKeyBindings
                       (GHCupInfo mempty mempty mempty)
                       (PlatformRequest A_64 Darwin Nothing)
+                      loggerConfig
 
 
 
-logger' :: IORef LoggerConfig
-{-# NOINLINE logger' #-}
-logger' = unsafePerformIO
-  (newIORef $ LoggerConfig { lcPrintDebug = False
-                           , colorOutter  = \_ -> pure ()
-                           , rawOutter    = \_ -> pure ()
-                           }
-  )
-
-
 brickMain :: AppState
-          -> LoggerConfig
           -> IO ()
-brickMain s l = do
+brickMain s = do
   writeIORef settings' s
-  -- logger interpreter
-  writeIORef logger'   l
-  let runLogger = myLoggerT l
 
   no_color <- isJust <$> lookupEnv "NO_COLOR"
 
@@ -601,7 +580,7 @@ brickMain s l = do
           )
         $> ()
     Left e -> do
-      runLogger ($(logError) [i|Error building app state: #{show e}|])
+      flip runReaderT s $ logError $ "Error building app state: " <> T.pack (show e)
       exitWith $ ExitFailure 2
 
 
@@ -612,13 +591,10 @@ defaultAppSettings = BrickSettings { showAllVersions = False, showAllTools = Fal
 getGHCupInfo :: IO (Either String GHCupInfo)
 getGHCupInfo = do
   settings <- readIORef settings'
-  l        <- readIORef logger'
-  let runLogger = myLoggerT l
 
   r <-
-    runLogger
+    flip runReaderT settings
-    . flip runReaderT settings
+    . runE @'[DigestError, GPGError, JSONError , DownloadFailed , FileDoesNotExistError]
-    . runE @'[JSONError , DownloadFailed , FileDoesNotExistError]
     $ liftE
     $ getDownloadsF
 
@@ -630,14 +606,11 @@ getGHCupInfo = do
 getAppData :: Maybe GHCupInfo
            -> IO (Either String BrickData)
 getAppData mgi = runExceptT $ do
-  l        <- liftIO $ readIORef logger'
-  let runLogger = myLoggerT l
-
   r <- ExceptT $ maybe getGHCupInfo (pure . Right) mgi
   liftIO $ modifyIORef settings' (\s -> s { ghcupInfo = r })
   settings <- liftIO $ readIORef settings'
 
-  runLogger . flip runReaderT settings $ do
+  flip runReaderT settings $ do
     lV <- listVersions Nothing Nothing
     pure $ BrickData (reverse lV)
 

cabal.ghc8107.project

@@ -8,26 +8,27 @@ package ghcup
     tests: True
     flags: +tui
 
-source-repository-package
-    type: git
-    location: https://github.com/jtdaugherty/brick.git
-    tag: b3b96cfe66dfd398d338e3feb2b6855e66a35190
-
-source-repository-package
-    type: git
-    location: https://github.com/Bodigrim/tar
-    tag: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
-
 source-repository-package
     type: git
     location: https://github.com/bgamari/terminal-size
     tag: 34ea816bd63f75f800eedac12c6908c6f3736036
 
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/libarchive
+    tag: 8587aab78dd515928024ecd82c8f215e06db85cd
+
 constraints: http-io-streams -brotli
 
 package libarchive
   flags: -system-libarchive
 
+package aeson-pretty
+  flags: +lib-only
+
+package cabal-plan
+  flags: -exe
+
 allow-newer: base, ghc-prim, template-haskell, language-c
 
-with-compiler: ghc-8.10.5
+with-compiler: ghc-8.10.7

cabal.ghc8107.project.freeze

@@ -1,15 +1,18 @@
 active-repositories: hackage.haskell.org:merge
 constraints: any.Cabal ==3.2.1.0,
              any.HUnit ==1.6.2.0,
-             any.HsOpenSSL ==0.11.7,
+             any.HsOpenSSL ==0.11.7.1,
              HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
+             any.HsYAML ==0.2.1.0,
+             HsYAML -exe,
+             any.HsYAML-aeson ==0.2.0.0,
              any.QuickCheck ==2.14.2,
              QuickCheck -old-random +templatehaskell,
              any.StateVar ==1.2.2,
              any.aeson ==1.5.6.0,
              aeson -bytestring-builder -cffi -developer -fast,
              any.aeson-pretty ==0.8.8,
-             aeson-pretty -lib-only,
+             aeson-pretty +lib-only,
              any.alex ==3.2.6,
              alex +small_base,
              any.ansi-terminal ==0.11,
@@ -22,8 +25,7 @@ constraints: any.Cabal ==3.2.1.0,
              async -bench,
              any.attoparsec ==0.13.2.5,
              attoparsec -developer,
-             any.auto-update ==0.1.6,
+             any.base ==4.14.3.0,
-             any.base ==4.14.2.0,
              any.base-compat ==0.11.2,
              any.base-compat-batteries ==0.11.2,
              any.base-orphans ==0.8.4,
@@ -32,41 +34,34 @@ constraints: any.Cabal ==3.2.1.0,
              any.bifunctors ==5.5.11,
              bifunctors +semigroups +tagged,
              any.binary ==0.8.8.0,
-             any.bindings-DSL ==1.0.25,
              any.blaze-builder ==0.4.2.1,
-             any.brick ==0.63,
+             any.brick ==0.64,
              brick -demos,
              any.bytestring ==0.10.12.0,
              any.bz2 ==1.0.1.0,
              bz2 -cross +with-bzlib,
-             any.bzlib-conduit ==0.3.0.2,
              any.c2hs ==0.28.8,
              c2hs +base3 -regression,
+             any.cabal-plan ==0.7.2.0,
+             cabal-plan -_ -exe -license-report,
              any.call-stack ==0.4.0,
              any.case-insensitive ==1.2.1.0,
              any.casing ==0.1.4.1,
-             any.cereal ==0.5.8.1,
-             cereal -bytestring-builder,
              any.chs-cabal ==0.1.1.0,
              any.chs-deps ==0.1.0.0,
              chs-deps -cross,
              any.clock ==0.8.2,
              clock -llvm,
-             any.cmdargs ==0.10.21,
-             cmdargs +quotation -testprog,
              any.colour ==2.3.6,
              any.comonad ==5.0.8,
              comonad +containers +distributive +indexed-traversable,
              any.composition-prelude ==3.0.0.2,
              composition-prelude -development,
              any.concurrent-output ==1.10.12,
-             any.conduit ==1.3.4.1,
-             any.conduit-extra ==1.3.5,
-             any.conduit-zstd ==0.0.2.0,
              any.config-ini ==0.2.4.0,
              config-ini -enable-doctests,
-             any.containers ==0.6.4.1,
+             any.containers ==0.6.5.1,
-             any.contravariant ==1.5.4,
+             any.contravariant ==1.5.5,
              contravariant +semigroups +statevar +tagged,
              any.cpphs ==1.20.9.1,
              cpphs -old-locale,
@@ -74,44 +69,32 @@ constraints: any.Cabal ==3.2.1.0,
              any.cryptohash-sha256 ==0.11.102.0,
              cryptohash-sha256 -exe +use-cbits,
              any.data-clist ==0.1.2.3,
-             any.data-default-class ==0.1.2.0,
+             any.data-fix ==0.3.2,
-             any.data-fix ==0.3.1,
              any.deepseq ==1.4.4.0,
-             any.digest ==0.0.1.3,
-             digest -bytestring-in-base,
              any.directory ==1.3.6.0,
              any.disk-free-space ==0.1.0.1,
              any.distributive ==0.6.2.1,
              distributive +semigroups +tagged,
              any.dlist ==1.0,
              dlist -werror,
-             any.easy-file ==0.2.2,
-             any.errors ==2.3.0,
              any.exceptions ==0.10.4,
-             any.extra ==1.7.9,
-             any.fast-logger ==3.0.5,
              any.filepath ==1.4.2.1,
              any.free ==5.1.7,
              any.generic-arbitrary ==0.1.0,
-             any.generics-sop ==0.5.1.1,
+             any.ghc-boot-th ==8.10.7,
-             any.ghc-boot-th ==8.10.5,
              any.ghc-byteorder ==4.11.0.0.10,
              any.ghc-prim ==0.6.1,
              any.happy ==1.20.0,
-             any.hashable ==1.3.2.0,
+             any.hashable ==1.3.3.0,
              hashable +integer-gmp -random-initial-seed,
-             any.haskell-src-exts ==1.23.1,
-             any.haskell-src-meta ==0.8.7,
              any.haskus-utils-data ==1.4,
              any.haskus-utils-types ==1.5.1,
              any.haskus-utils-variant ==3.1,
-             any.hpath-filepath ==0.10.4,
-             any.hpath-posix ==0.13.3,
              any.hsc2hs ==0.68.7,
              hsc2hs -in-ghc-tree,
              any.hspec ==2.7.10,
              any.hspec-core ==2.7.10,
-             any.hspec-discover ==2.7.10 || ==2.8.2,
+             any.hspec-discover ==2.7.10 || ==2.8.3,
              any.hspec-expectations ==0.8.2,
              any.hspec-golden-aeson ==0.9.0.0,
              any.http-io-streams ==0.1.6.0,
@@ -128,34 +111,22 @@ constraints: any.Cabal ==3.2.1.0,
              language-c -allwarnings +iecfpextension +usebytestrings,
              any.libarchive ==3.0.2.2,
              libarchive -cross -low-memory -system-libarchive,
-             any.libyaml ==0.1.2,
-             libyaml -no-unicode -system-libyaml,
-             any.lifted-base ==0.2.3.12,
              any.lzma-static ==5.2.5.4,
              any.megaparsec ==9.0.1,
              megaparsec -dev,
              any.microlens ==0.4.12.0,
              any.microlens-mtl ==0.2.0.1,
              any.microlens-th ==0.4.3.10,
-             any.monad-control ==1.0.3,
-             any.monad-logger ==0.3.36,
-             monad-logger +template_haskell,
-             any.monad-loops ==0.4.3,
-             monad-loops +base4,
-             any.mono-traversable ==1.0.15.1,
              any.mtl ==2.2.2,
              any.network ==3.1.2.2,
              network -devel,
              any.network-uri ==2.6.4.1,
-             any.old-locale ==1.0.0.7,
-             any.old-time ==1.1.0.3,
              any.openssl-streams ==1.2.3.0,
              any.optics ==0.4,
              any.optics-core ==0.4,
              optics-core -explicit-generic-labels,
              any.optics-extra ==0.4,
              any.optics-th ==0.4,
-             any.optics-vl ==0.2.1,
              any.optparse-applicative ==0.16.1.0,
              optparse-applicative +process,
              any.os-release ==1.0.2,
@@ -167,8 +138,8 @@ constraints: any.Cabal ==3.2.1.0,
              any.polyparse ==1.13,
              any.pretty ==1.1.3.6,
              any.pretty-terminal ==0.1.0.0,
-             any.primitive ==0.7.1.0,
+             any.primitive ==0.7.2.0,
-             any.process ==1.6.9.0,
+             any.process ==1.6.13.2,
              any.profunctors ==5.6.2,
              any.quickcheck-arbitrary-adt ==0.3.1.0,
              any.quickcheck-io ==0.2.0,
@@ -178,7 +149,7 @@ constraints: any.Cabal ==3.2.1.0,
              any.regex-base ==0.94.0.1,
              any.regex-posix ==0.96.0.1,
              regex-posix -_regex-posix-clib,
-             any.resourcet ==1.2.4.2,
+             any.resourcet ==1.2.4.3,
              any.rts ==1.0.1,
              any.safe ==0.3.19,
              any.safe-exceptions ==0.1.7.2,
@@ -187,55 +158,41 @@ constraints: any.Cabal ==3.2.1.0,
              any.semigroupoids ==5.3.5,
              semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
              any.setenv ==0.1.1.3,
-             any.sop-core ==0.5.0.1,
              any.split ==0.2.3.4,
              any.splitmix ==0.1.0.3,
              splitmix -optimised-mixer,
              any.stm ==2.5.0.1,
-             any.stm-chans ==3.0.0.4,
-             any.streaming-commons ==0.2.2.1,
-             streaming-commons -use-bytestring-builder,
              any.strict ==0.4.0.1,
              strict +assoc,
              any.strict-base ==0.4.0.0,
-             any.string-interpolate ==0.3.1.1,
-             string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
-             any.syb ==0.7.2.1,
              any.tagged ==0.8.6.1,
              tagged +deepseq +transformers,
-             any.tar ==0.6.0.0,
              any.template-haskell ==2.16.0.0,
              any.temporary ==1.3,
              any.terminal-progress-bar ==0.4.1,
              any.terminal-size ==0.3.2.1,
              any.terminfo ==0.4.1.4,
              any.text ==1.2.4.1,
-             any.text-conversions ==0.3.1,
              any.text-zipper ==0.11,
              any.tf-random ==0.5,
              any.th-abstraction ==0.4.2.0,
              any.th-compat ==0.1.2,
-             any.th-expand-syns ==0.4.8.0,
              any.th-lift ==0.8.2,
              any.th-lift-instances ==0.1.18,
-             any.th-orphans ==0.13.11,
-             any.th-reify-many ==0.1.9,
              any.these ==1.1.1.1,
              these +assoc,
              any.time ==1.9.3,
              any.time-compat ==1.9.6,
              time-compat -old-locale,
              any.transformers ==0.5.6.2,
-             any.transformers-base ==0.4.5.2,
+             any.transformers-base ==0.4.6,
              transformers-base +orphaninstances,
              any.transformers-compat ==0.7,
              transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
-             any.typed-process ==0.2.6.0,
              any.unix ==2.7.2.2,
              any.unix-bytestring ==0.3.7.3,
              any.unix-compat ==0.5.3,
              unix-compat -old-time,
-             any.unix-time ==0.4.7,
              any.unliftio-core ==0.2.0.1,
              any.unordered-containers ==0.2.14.0,
              unordered-containers -debug,
@@ -245,20 +202,12 @@ constraints: any.Cabal ==3.2.1.0,
              any.uuid-types ==1.0.5,
              any.vector ==0.12.3.0,
              vector +boundschecks -internalchecks -unsafechecks -wall,
-             any.vector-algorithms ==0.8.0.4,
-             vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
              any.versions ==5.0.0,
              any.vty ==5.33,
              any.word-wrap ==0.4.1,
              any.word8 ==0.1.3,
              any.xor ==0.0.1.0,
-             any.yaml ==0.11.5.0,
-             yaml +no-examples +no-exe,
-             any.zip ==1.7.1,
-             zip -dev -disable-bzip2 -disable-zstd,
              any.zlib ==0.6.2.3,
              zlib -bundled-c-zlib -non-blocking-ffi -pkg-config,
-             any.zlib-bindings ==0.1.1.5,
+             any.zlib-bindings ==0.1.1.5
-             any.zstd ==0.1.2.0,
+index-state: hackage.haskell.org 2021-08-29T16:24:29Z
-             zstd +standalone
-index-state: hackage.haskell.org 2021-07-27T07:59:57Z

cabal.ghc901.project

@@ -8,26 +8,27 @@ package ghcup
     tests: True
     flags: +tui
 
-source-repository-package
-    type: git
-    location: https://github.com/jtdaugherty/brick.git
-    tag: b3b96cfe66dfd398d338e3feb2b6855e66a35190
-
-source-repository-package
-    type: git
-    location: https://github.com/Bodigrim/tar
-    tag: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
-
 source-repository-package
     type: git
     location: https://github.com/bgamari/terminal-size
     tag: 34ea816bd63f75f800eedac12c6908c6f3736036
 
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/libarchive
+    tag: 8587aab78dd515928024ecd82c8f215e06db85cd
+
 constraints: http-io-streams -brotli
 
 package libarchive
   flags: -system-libarchive
 
+package aeson-pretty
+  flags: +lib-only
+
+package cabal-plan
+  flags: -exe
+
 allow-newer: base, ghc-prim, template-haskell, language-c
 
 with-compiler: ghc-9.0.1

cabal.ghc901.project.freeze

@@ -1,15 +1,18 @@
 active-repositories: hackage.haskell.org:merge
 constraints: any.Cabal ==3.4.0.0,
              any.HUnit ==1.6.2.0,
-             any.HsOpenSSL ==0.11.7,
+             any.HsOpenSSL ==0.11.7.1,
              HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
+             any.HsYAML ==0.2.1.0,
+             HsYAML -exe,
+             any.HsYAML-aeson ==0.2.0.0,
              any.QuickCheck ==2.14.2,
              QuickCheck -old-random +templatehaskell,
              any.StateVar ==1.2.2,
              any.aeson ==1.5.6.0,
              aeson -bytestring-builder -cffi -developer -fast,
              any.aeson-pretty ==0.8.8,
-             aeson-pretty -lib-only,
+             aeson-pretty +lib-only,
              any.alex ==3.2.6,
              alex +small_base,
              any.ansi-terminal ==0.11,
@@ -22,7 +25,6 @@ constraints: any.Cabal ==3.4.0.0,
              async -bench,
              any.attoparsec ==0.13.2.5,
              attoparsec -developer,
-             any.auto-update ==0.1.6,
              any.base ==4.15.0.0,
              any.base-compat ==0.11.2,
              any.base-compat-batteries ==0.11.2,
@@ -32,41 +34,34 @@ constraints: any.Cabal ==3.4.0.0,
              any.bifunctors ==5.5.11,
              bifunctors +semigroups +tagged,
              any.binary ==0.8.8.0,
-             any.bindings-DSL ==1.0.25,
              any.blaze-builder ==0.4.2.1,
-             any.brick ==0.63,
+             any.brick ==0.64,
              brick -demos,
              any.bytestring ==0.10.12.1,
              any.bz2 ==1.0.1.0,
              bz2 -cross +with-bzlib,
-             any.bzlib-conduit ==0.3.0.2,
              any.c2hs ==0.28.8,
              c2hs +base3 -regression,
+             any.cabal-plan ==0.7.2.0,
+             cabal-plan -_ -exe -license-report,
              any.call-stack ==0.4.0,
              any.case-insensitive ==1.2.1.0,
              any.casing ==0.1.4.1,
-             any.cereal ==0.5.8.1,
-             cereal -bytestring-builder,
              any.chs-cabal ==0.1.1.0,
              any.chs-deps ==0.1.0.0,
              chs-deps -cross,
              any.clock ==0.8.2,
              clock -llvm,
-             any.cmdargs ==0.10.21,
-             cmdargs +quotation -testprog,
              any.colour ==2.3.6,
              any.comonad ==5.0.8,
              comonad +containers +distributive +indexed-traversable,
              any.composition-prelude ==3.0.0.2,
              composition-prelude -development,
              any.concurrent-output ==1.10.12,
-             any.conduit ==1.3.4.1,
-             any.conduit-extra ==1.3.5,
-             any.conduit-zstd ==0.0.2.0,
              any.config-ini ==0.2.4.0,
              config-ini -enable-doctests,
              any.containers ==0.6.4.1,
-             any.contravariant ==1.5.4,
+             any.contravariant ==1.5.5,
              contravariant +semigroups +statevar +tagged,
              any.cpphs ==1.20.9.1,
              cpphs -old-locale,
@@ -74,45 +69,33 @@ constraints: any.Cabal ==3.4.0.0,
              any.cryptohash-sha256 ==0.11.102.0,
              cryptohash-sha256 -exe +use-cbits,
              any.data-clist ==0.1.2.3,
-             any.data-default-class ==0.1.2.0,
+             any.data-fix ==0.3.2,
-             any.data-fix ==0.3.1,
              any.deepseq ==1.4.5.0,
-             any.digest ==0.0.1.3,
-             digest -bytestring-in-base,
              any.directory ==1.3.6.1,
              any.disk-free-space ==0.1.0.1,
              any.distributive ==0.6.2.1,
              distributive +semigroups +tagged,
              any.dlist ==1.0,
              dlist -werror,
-             any.easy-file ==0.2.2,
-             any.errors ==2.3.0,
              any.exceptions ==0.10.4,
-             any.extra ==1.7.9,
-             any.fast-logger ==3.0.5,
              any.filepath ==1.4.2.1,
              any.free ==5.1.7,
              any.generic-arbitrary ==0.1.0,
-             any.generics-sop ==0.5.1.1,
              any.ghc-bignum ==1.0,
              any.ghc-boot-th ==9.0.1,
              any.ghc-byteorder ==4.11.0.0.10,
              any.ghc-prim ==0.7.0,
              any.happy ==1.20.0,
-             any.hashable ==1.3.2.0,
+             any.hashable ==1.3.3.0,
              hashable +integer-gmp -random-initial-seed,
-             any.haskell-src-exts ==1.23.1,
-             any.haskell-src-meta ==0.8.7,
              any.haskus-utils-data ==1.4,
              any.haskus-utils-types ==1.5.1,
              any.haskus-utils-variant ==3.1,
-             any.hpath-filepath ==0.10.4,
-             any.hpath-posix ==0.13.3,
              any.hsc2hs ==0.68.7,
              hsc2hs -in-ghc-tree,
              any.hspec ==2.7.10,
              any.hspec-core ==2.7.10,
-             any.hspec-discover ==2.7.10 || ==2.8.2,
+             any.hspec-discover ==2.7.10 || ==2.8.3,
              any.hspec-expectations ==0.8.2,
              any.hspec-golden-aeson ==0.9.0.0,
              any.http-io-streams ==0.1.6.0,
@@ -128,34 +111,22 @@ constraints: any.Cabal ==3.4.0.0,
              language-c -allwarnings +iecfpextension +usebytestrings,
              any.libarchive ==3.0.2.2,
              libarchive -cross -low-memory -system-libarchive,
-             any.libyaml ==0.1.2,
-             libyaml -no-unicode -system-libyaml,
-             any.lifted-base ==0.2.3.12,
              any.lzma-static ==5.2.5.4,
              any.megaparsec ==9.0.1,
              megaparsec -dev,
              any.microlens ==0.4.12.0,
              any.microlens-mtl ==0.2.0.1,
              any.microlens-th ==0.4.3.10,
-             any.monad-control ==1.0.3,
-             any.monad-logger ==0.3.36,
-             monad-logger +template_haskell,
-             any.monad-loops ==0.4.3,
-             monad-loops +base4,
-             any.mono-traversable ==1.0.15.1,
              any.mtl ==2.2.2,
              any.network ==3.1.2.2,
              network -devel,
              any.network-uri ==2.6.4.1,
-             any.old-locale ==1.0.0.7,
-             any.old-time ==1.1.0.3,
              any.openssl-streams ==1.2.3.0,
              any.optics ==0.4,
              any.optics-core ==0.4,
              optics-core -explicit-generic-labels,
              any.optics-extra ==0.4,
              any.optics-th ==0.4,
-             any.optics-vl ==0.2.1,
              any.optparse-applicative ==0.16.1.0,
              optparse-applicative +process,
              any.os-release ==1.0.2,
@@ -167,7 +138,7 @@ constraints: any.Cabal ==3.4.0.0,
              any.polyparse ==1.13,
              any.pretty ==1.1.3.6,
              any.pretty-terminal ==0.1.0.0,
-             any.primitive ==0.7.1.0,
+             any.primitive ==0.7.2.0,
              any.process ==1.6.11.0,
              any.profunctors ==5.6.2,
              any.quickcheck-arbitrary-adt ==0.3.1.0,
@@ -178,7 +149,7 @@ constraints: any.Cabal ==3.4.0.0,
              any.regex-base ==0.94.0.1,
              any.regex-posix ==0.96.0.1,
              regex-posix -_regex-posix-clib,
-             any.resourcet ==1.2.4.2,
+             any.resourcet ==1.2.4.3,
              any.rts ==1.0,
              any.safe ==0.3.19,
              any.safe-exceptions ==0.1.7.2,
@@ -187,55 +158,41 @@ constraints: any.Cabal ==3.4.0.0,
              any.semigroupoids ==5.3.5,
              semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
              any.setenv ==0.1.1.3,
-             any.sop-core ==0.5.0.1,
              any.split ==0.2.3.4,
              any.splitmix ==0.1.0.3,
              splitmix -optimised-mixer,
              any.stm ==2.5.0.0,
-             any.stm-chans ==3.0.0.4,
-             any.streaming-commons ==0.2.2.1,
-             streaming-commons -use-bytestring-builder,
              any.strict ==0.4.0.1,
              strict +assoc,
              any.strict-base ==0.4.0.0,
-             any.string-interpolate ==0.3.1.1,
-             string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
-             any.syb ==0.7.2.1,
              any.tagged ==0.8.6.1,
              tagged +deepseq +transformers,
-             any.tar ==0.6.0.0,
              any.template-haskell ==2.17.0.0,
              any.temporary ==1.3,
              any.terminal-progress-bar ==0.4.1,
              any.terminal-size ==0.3.2.1,
              any.terminfo ==0.4.1.4,
              any.text ==1.2.4.1,
-             any.text-conversions ==0.3.1,
              any.text-zipper ==0.11,
              any.tf-random ==0.5,
              any.th-abstraction ==0.4.2.0,
              any.th-compat ==0.1.2,
-             any.th-expand-syns ==0.4.8.0,
              any.th-lift ==0.8.2,
              any.th-lift-instances ==0.1.18,
-             any.th-orphans ==0.13.11,
-             any.th-reify-many ==0.1.9,
              any.these ==1.1.1.1,
              these +assoc,
              any.time ==1.9.3,
              any.time-compat ==1.9.6,
              time-compat -old-locale,
              any.transformers ==0.5.6.2,
-             any.transformers-base ==0.4.5.2,
+             any.transformers-base ==0.4.6,
              transformers-base +orphaninstances,
              any.transformers-compat ==0.7,
              transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
-             any.typed-process ==0.2.6.0,
              any.unix ==2.7.2.2,
              any.unix-bytestring ==0.3.7.3,
              any.unix-compat ==0.5.3,
              unix-compat -old-time,
-             any.unix-time ==0.4.7,
              any.unliftio-core ==0.2.0.1,
              any.unordered-containers ==0.2.14.0,
              unordered-containers -debug,
@@ -245,20 +202,12 @@ constraints: any.Cabal ==3.4.0.0,
              any.uuid-types ==1.0.5,
              any.vector ==0.12.3.0,
              vector +boundschecks -internalchecks -unsafechecks -wall,
-             any.vector-algorithms ==0.8.0.4,
-             vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
              any.versions ==5.0.0,
              any.vty ==5.33,
              any.word-wrap ==0.4.1,
              any.word8 ==0.1.3,
              any.xor ==0.0.1.0,
-             any.yaml ==0.11.5.0,
-             yaml +no-examples +no-exe,
-             any.zip ==1.7.1,
-             zip -dev -disable-bzip2 -disable-zstd,
              any.zlib ==0.6.2.3,
              zlib -bundled-c-zlib -non-blocking-ffi -pkg-config,
-             any.zlib-bindings ==0.1.1.5,
+             any.zlib-bindings ==0.1.1.5
-             any.zstd ==0.1.2.0,
+index-state: hackage.haskell.org 2021-08-29T16:24:29Z
-             zstd +standalone
-index-state: hackage.haskell.org 2021-07-27T07:59:57Z

cabal.project

@@ -8,24 +8,25 @@ package ghcup
     tests: True
     flags: +tui
 
-source-repository-package
-    type: git
-    location: https://github.com/jtdaugherty/brick.git
-    tag: b3b96cfe66dfd398d338e3feb2b6855e66a35190
-
-source-repository-package
-    type: git
-    location: https://github.com/Bodigrim/tar
-    tag: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
-
 source-repository-package
     type: git
     location: https://github.com/bgamari/terminal-size
     tag: 34ea816bd63f75f800eedac12c6908c6f3736036
 
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/libarchive
+    tag: 8587aab78dd515928024ecd82c8f215e06db85cd
+
 constraints: http-io-streams -brotli
 
 package libarchive
   flags: -system-libarchive
 
+package aeson-pretty
+  flags: +lib-only
+
+package cabal-plan
+  flags: -exe
+
 allow-newer: base, ghc-prim, template-haskell, language-c

data/build_mk/cross

@@ -0,0 +1,9 @@
+V=0
+BUILD_MAN = NO
+BUILD_SPHINX_HTML = NO
+BUILD_SPHINX_PDF = NO
+HADDOCK_DOCS = NO
+ifneq "$(BuildFlavour)" ""
+include mk/flavours/$(BuildFlavour).mk
+endif
+Stage1Only = YES

data/build_mk/default

@@ -0,0 +1,8 @@
+V=0
+BUILD_MAN = NO
+BUILD_SPHINX_HTML = NO
+BUILD_SPHINX_PDF = NO
+HADDOCK_DOCS = YES
+ifneq "$(BuildFlavour)" ""
+include mk/flavours/$(BuildFlavour).mk
+endif

data/config.yaml

@@ -8,6 +8,10 @@ verbose: False
 keep-dirs: Errors  # Always | Never | Errors
 # Which downloader to use
 downloader: Curl   # Curl | Wget | Internal
+# whether to run in offline mode
+no-network: False
+# whether/how to do gpg verification
+gpg-setting: GPGNone # GPGStrict | GPGLax | GPGNone
 
 # TUI key bindings,
 # see https://hackage.haskell.org/package/vty-5.31/docs/Graphics-Vty-Input-Events.html#t:Key

data/metadata/ghcup-0.0.6.yaml

@@ -72,7 +72,6 @@ toolRequirements:
         '( >= 7 && < 8 )':
           distroPKGs:
           - gcc
-          - gcc-c++
           - gmp
           - gmp-devel
           - make
@@ -83,7 +82,6 @@ toolRequirements:
         unknown_versioning:
           distroPKGs:
           - gcc
-          - gcc-c++
           - gmp
           - gmp-devel
           - make
@@ -96,7 +94,6 @@ toolRequirements:
         unknown_versioning:
           distroPKGs:
           - gcc
-          - gcc-c++
           - gmp
           - gmp-devel
           - make
@@ -111,14 +108,15 @@ toolRequirements:
           - binutils-gold
           - curl
           - gcc
-          - g++
           - gmp-dev
-          - ncurses-dev
+          - libc-dev
           - libffi-dev
           - make
-          - xz
+          - musl-dev
-          - tar
+          - ncurses-dev
           - perl
+          - tar
+          - xz
           notes: ''
       Linux_UnknownLinux:
         unknown_versioning:
@@ -1598,6 +1596,11 @@ ghcupDownloads:
         dlHash: f10941f16e4fbd98580ab5241b9271bb0851304560c4d5ca127e3b0e20e3076f
       viPostRemove: *ghc-post-remove
       viPreCompile: *ghc-pre-compile
+      viPostInstall: &ghc-8105-post-install |
+        GHC 8.10.5 and 8.10.6 have several issues on Darwin, e.g.
+          https://gitlab.haskell.org/ghc/ghc/-/issues/19950
+        Consider upgrading to 8.10.7 via
+          ghcup install ghc --set 8.10.7
       viArch:
         A_64:
           Linux_Debian:
@@ -1690,7 +1693,6 @@ ghcupDownloads:
               dlHash: 56170d1a8450e18b7eb9c23c94723da352815b27ec250bb23742a62f16dcab6c
     8.10.6:
       viTags:
-      - Recommended
       - base-4.14.3.0
       viChangeLog: https://downloads.haskell.org/~ghc/8.10.6/docs/html/users_guide/8.10.6-notes.html
       viSourceDL:
@@ -1699,6 +1701,7 @@ ghcupDownloads:
         dlHash: 43afba72a533408b42c1492bd047b5e37e5f7204e41a5cedd3182cc841610ce9
       viPostRemove: *ghc-post-remove
       viPreCompile: *ghc-pre-compile
+      viPostInstall: *ghc-8105-post-install
       viArch:
         A_64:
           Linux_Debian:
@@ -1789,6 +1792,107 @@ ghcupDownloads:
               dlUri: https://downloads.haskell.org/~ghc/8.10.6/ghc-8.10.6-armv7-deb10-linux.tar.xz
               dlSubdir: ghc-8.10.6
               dlHash: d54de8306aa8b33afabf2ac94408e1f82c8e982a2a3346168c071b92bdb464c0
+    8.10.7:
+      viTags:
+      - Recommended
+      - base-4.14.3.0
+      viChangeLog: https://downloads.haskell.org/~ghc/8.10.7/docs/html/users_guide/8.10.7-notes.html
+      viSourceDL:
+        dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-src.tar.xz
+        dlSubdir: ghc-8.10.7
+        dlHash: e3eef6229ce9908dfe1ea41436befb0455fefb1932559e860ad4c606b0d03c9d
+      viPostRemove: *ghc-post-remove
+      viPreCompile: *ghc-pre-compile
+      viArch:
+        A_64:
+          Linux_Debian:
+            '( >= 9 && < 10 )': &ghc-8107-64-deb9
+              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.7
+              dlHash: ced9870ea351af64fb48274b81a664cdb6a9266775f1598a79cbb6fdd5770a23
+            '( >= 10 && < 11 )': &ghc-8107-64-deb10
+              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.7
+              dlHash: a13719bca87a0d3ac0c7d4157a4e60887009a7f1a8dbe95c4759ec413e086d30
+            unknown_versioning: *ghc-8107-64-deb9
+          Linux_Ubuntu:
+            unknown_versioning: &ghc-8107-64-fedora
+              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-fedora27-linux.tar.xz
+              dlSubdir: ghc-8.10.7
+              dlHash: b6ed67049a23054a8042e65c9976d5e196e5ee4e83b29b2ee35c8a22ab1e5b73
+            '( >= 16 && < 19 )': *ghc-8107-64-deb9
+          Linux_Mint:
+            unknown_versioning: *ghc-8107-64-deb10
+          Linux_Fedora:
+            '( >= 27 && < 28 )': *ghc-8107-64-fedora
+            unknown_versioning: *ghc-8107-64-fedora
+          Linux_CentOS:
+            '( >= 7 && < 8 )': &ghc-8107-64-centos
+              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-centos7-linux.tar.xz
+              dlSubdir: ghc-8.10.7
+              dlHash: 262a50bfb5b7c8770e0d99f54d42e5876968da7bf93e2e4d6cfe397891a36d05
+            unknown_versioning: *ghc-8107-64-centos
+          Linux_RedHat:
+            unknown_versioning: *ghc-8107-64-centos
+          Linux_Alpine:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-alpine3.10-linux-integer-simple.tar.xz
+              dlSubdir: ghc-8.10.7-x86_64-unknown-linux
+              dlHash: 16903df850ef73d5246f2ff169cbf57ecab76c2ac5acfa9928934282cfad575c
+          Linux_AmazonLinux:
+            unknown_versioning: *ghc-8107-64-centos
+          Linux_UnknownLinux:
+            unknown_versioning: *ghc-8107-64-fedora
+          Darwin:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-apple-darwin.tar.xz
+              dlSubdir: ghc-8.10.7
+              dlHash: 287db0f9c338c9f53123bfa8731b0996803ee50f6ee847fe388092e5e5132047
+          FreeBSD:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-unknown-freebsd.tar.xz
+              dlSubdir: ghc-8.10.7
+              dlHash: 45e35d24bc700e1093efa39189e9fa01498069881aed2fa8779c011941a80da1
+          Windows:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-x86_64-unknown-mingw32.tar.xz
+              dlSubdir: ghc-8.10.7
+              dlHash: b6515b0ea3f7a6e34d92e7fcd0c1fef50d6030fe8f46883000185289a4b8ea9a
+        A_32:
+          Linux_Debian:
+            '( >= 9 && < 10 )': &ghc-8107-32-deb9
+              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-i386-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.7
+              dlHash: fbfc1ef194f4e7a4c0da8c11cc69b17458a4b928b609b3622c97acc4acd5c5ab
+            unknown_versioning: *ghc-8107-32-deb9
+          Linux_Ubuntu:
+            unknown_versioning: *ghc-8107-32-deb9
+          Linux_Mint:
+            unknown_versioning: *ghc-8107-32-deb9
+          Linux_UnknownLinux:
+            unknown_versioning: *ghc-8107-32-deb9
+          Linux_Alpine:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/ghc/8.10.7/ghc-8.10.7-i386-alpine-linux.tar.xz
+              dlSubdir: ghc-8.10.7
+              dlHash: 3110e6ee029d9d8062158b54b06f71a21b0fac87bf0e085f9be5bbcf73f99e6d
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-aarch64-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.7
+              dlHash: fad2417f9b295233bf8ade79c0e6140896359e87be46cb61cd1d35863d9d0e55
+          Darwin:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-aarch64-apple-darwin.tar.xz
+              dlSubdir: ghc-8.10.7
+              dlHash: dc469fc3c35fd2a33a5a575ffce87f13de7b98c2d349a41002e200a56d9bba1c
+        A_ARM:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.7/ghc-8.10.7-armv7-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.7
+              dlHash: 3949c31bdf7d3b4afb765ea8246bca4ca9707c5d988d9961a244f0da100956a2
     9.0.1:
       viTags:
       - Latest
@@ -2072,7 +2176,6 @@ ghcupDownloads:
     3.4.0.0:
       viTags:
       - Recommended
-      - Latest
       viChangeLog: https://github.com/haskell/cabal/blob/master/release-notes/cabal-install-3.4.0.0.md
       viArch:
         A_64:
@@ -2121,8 +2224,52 @@ ghcupDownloads:
             unknown_versioning:
               dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.4.0.0/cabal-install-3.4.0.0-armv7-linux-bootstrapped.tar.xz
               dlHash: 16c0d1eaba24bed14f3e152970179a45d9f9bb5cc839b2c210ad06eb7d4826ed
+    3.6.0.0:
+      viTags:
+      - Latest
+      viChangeLog: https://github.com/haskell/cabal/blob/master/release-notes/cabal-install-3.6.0.0.md
+      viArch:
+        A_64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.6.0.0/cabal-install-3.6.0.0-x86_64-linux.tar.xz
+              dlHash: bfcb7350966dafe95051b5fc9fcb989c5708ab9e78191e71fc04647061668a11
+          Linux_Alpine:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.6.0.0/cabal-install-3.6.0.0-x86_64-linux-alpine.tar.xz
+              dlHash: 3203d71b7ee87fc9dce74b452ae07f420afe8817b5e6f84e54798442f4ccdda8
+          Darwin:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.6.0.0/cabal-install-3.6.0.0-x86_64-darwin.tar.xz
+              dlHash: 8e1367a4a1fc86ff0fd82ee057320a7b974595ba7999457b42035467ba06190c
+          FreeBSD:
+            '( >= 12 && < 13 )':
+              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.6.0.0/cabal-install-3.6.0.0-x86_64-freebsd.tar.xz
+              dlHash: 56b5b37396c16a29f164a6963f24bd88f09e1d37448542ed61a683325f0a868b
+            '( >= 13 )':
+              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.6.0.0/cabal-install-3.6.0.0-x86_64-freebsd13.tar.xz
+              dlHash: a283aa498702a3e286aa08e004c2a389538cbb47ec7096a25682fb7d57f6bb7f
+          Windows:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.6.0.0/cabal-install-3.6.0.0-x86_64-windows.zip
+              dlSubdir:
+              dlHash: 8222b49b6eac3d06aaa390bc688f467e8f949a38943567f46246f8320fd72ded
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.6.0.0/cabal-install-3.6.0.0-aarch64-linux-deb10.tar.xz
+              dlHash: 534f71cd4e1d9758dc73066cc5733c5838874710aeb3aa88541de6c6d042d9ec
+          Darwin:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.6.0.0/cabal-install-3.6.0.0-aarch64-darwin-big-sur.tar.xz
+              dlHash: 7acf740946d996ede835edf68887e6b2f1e16d1b95e94054d266463f38d136d9
+        A_ARM:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.6.0.0/cabal-install-3.6.0.0-armv7-linux.tar.xz
+              dlHash: 11b5ca042a8bf45971224f2127a3e9d6b803f09210042ca80a254bea06f01a2e
   GHCup:
-    0.1.16.2:
+    0.1.17:
       viTags:
       - Recommended
       - Latest
@@ -2132,46 +2279,47 @@ ghcupDownloads:
         A_64:
           Linux_UnknownLinux:
             unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-linux-ghcup-0.1.16.2
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.17/x86_64-linux-ghcup-0.1.17
-              dlHash: d5e43b95ce1d42263376e414f7eb7c5dd440271c7c6cd9bad446fdeff3823893
+              dlHash: 1eaa33af4180f97edf02822d6d711ce618d9828fe9ebbf042d198fe6c1c9d153
           Darwin:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-apple-darwin-ghcup-0.1.16.2
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.17/x86_64-apple-darwin-ghcup-0.1.17
-              dlHash: a334620ccce7705211b2142882dde544003e6030af4b91a44c890542a90f879f
+              dlHash: a3d4ed12f8631c0537d8d9531cc5518bc6f90edcee3326e5d4e0efb72c8dfc6f
           FreeBSD:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-portbld-freebsd-ghcup-0.1.16.2
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.17/x86_64-portbld-freebsd-ghcup-0.1.17
-              dlHash: 92359592a5694375e53b22628920086bf4bbf0faff5be018a0ed3e745a6426a9
+              dlHash: 83012de837773f3aa26182c607c2da85ee6ff3b0092becb78907700f407a27fb
           Windows:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/x86_64-mingw64-ghcup-0.1.16.2.exe
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.17/x86_64-mingw64-ghcup-0.1.17.exe
-              dlHash: ec78872a84213968c490675127b9aad2285980b747c68207801ae824b98c7948
+              dlHash: 40bda6050c800fa69af51d2e668426ca73b4179214bfeef329b795484991d258
           Linux_Alpine:
             unknown_versioning: *ghcup-64
         A_32:
           Linux_UnknownLinux:
             unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/i386-linux-ghcup-0.1.16.2
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.17/i386-linux-ghcup-0.1.17
-              dlHash: 01968ca6decac7b6e8ba6e2c817870d3fa47289a6507e0c1ab563f7b6eec0e38
+              dlHash: d0f887b13a2c7a11477dc54cb90b446ef0ebe1d2a6bfbf60ccd4b37fc5de70cc
           Linux_Alpine:
             unknown_versioning: *ghcup-32
         A_ARM64:
           Linux_UnknownLinux:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/aarch64-linux-ghcup-0.1.16.2
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.17/aarch64-linux-ghcup-0.1.17
-              dlHash: 0bdbfc724e0ddabb266156eea83c2c4e19c6ed79dd06db0c29b7d69df8d9fa8c
+              dlHash: be67cf8800ae305c5ba210b645f4fce8751763f3eac3db399f6efca145b7ab38
           Darwin:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/aarch64-apple-darwin-ghcup-0.1.16.2
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.17/aarch64-apple-darwin-ghcup-0.1.17
-              dlHash: 8854e991a2ba1350abda59dab96ce50ae7729d1ce99399d67929ef31e90f1da5
+              dlHash: b1be8c55838bd0d972e42b02b71bdf47fbbf67be1456e0de2d7d346620538539
         A_ARM:
           Linux_UnknownLinux:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.16.2/armv7-linux-ghcup-0.1.16.2
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.17/armv7-linux-ghcup-0.1.17
-              dlHash: 983ebb5b584bfa600704216a63f94b40d36a02573834e90ef1042c8472d9ad57
+              dlHash: fe54ded2fafff4f8d82e511229f257f4c3b87b14c796f9b5b0ea35c359c26cb0
   HLS:
     1.1.0:
-      viTags: []
+      viTags:
+        - old
       viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#110
       viPostInstall: &hls-post-install |
         This is just the server part of your LSP configuration. Consult the README on how to
@@ -2194,7 +2342,8 @@ ghcupDownloads:
           Linux_Alpine:
             unknown_versioning: *hls-110-64
     1.2.0:
-      viTags: []
+      viTags:
+        - old
       viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#120
       viPostInstall: *hls-post-install
       viArch:
@@ -2214,9 +2363,7 @@ ghcupDownloads:
           Linux_Alpine:
             unknown_versioning: *hls-120-64
     1.3.0:
-      viTags:
+      viTags: []
-        - Recommended
-        - Latest
       viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#130
       viPostInstall: *hls-post-install
       viArch:
@@ -2235,6 +2382,50 @@ ghcupDownloads:
               dlHash: 46aac7be888e29a9907cf56698c1ce1475c148b5e6cc099513e9ef74a0520dcf
           Linux_Alpine:
             unknown_versioning: *hls-130-64
+    1.4.0:
+      viTags:
+        - Recommended
+        - Latest
+      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#140
+      viPostInstall: *hls-post-install
+      viSourceDL:
+        dlUri: https://downloads.haskell.org/ghcup/src/haskell-language-server/1.4.0/haskell-language-server-1.4.0.tar.gz
+        dlSubdir: haskell-language-server-1.4.0
+        dlHash: c5d7dbf7fae9aa3ed2c1184b49e82d8ac623ca786494ef6602cfe11735d28db0
+      viArch:
+        A_64:
+          Linux_UnknownLinux:
+            unknown_versioning: &hls-140-64
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.4.0/haskell-language-server-Linux-1.4.0.tar.gz
+              dlHash: f93c114441911ccce55649702adc9553cb4c9f953c37878321d2806a3525fee8
+          Darwin:
+            unknown_versioning:
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.4.0/haskell-language-server-macOS-1.4.0.tar.gz
+              dlHash: a7f0ac6be93ffb08cc239e5f5fead99b061061825f99566c1be33ee60cab62a4
+          FreeBSD:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/haskell-language-server/1.4.0/haskell-language-server-freebsd-1.4.0.tar.gz
+              dlHash: 6b2ad2398ed8c3964dea017e3d5e553b54c10ba1373d7653d2edd019854f4da2
+          Windows:
+            unknown_versioning:
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.4.0/haskell-language-server-Windows-1.4.0.tar.gz
+              dlHash: 0ec77cee750037b7a0ede817b46a913a702821f4098c6a858bcb686cb30f7efd
+          Linux_Alpine:
+            unknown_versioning: *hls-140-64
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/haskell-language-server/1.4.0/haskell-language-server-linux-aarch64-1.4.0.tar.gz
+              dlHash: 8ad97e2bf1c538e637edec194e1cd9939019955bb749cb470f34bbe5a067b001
+          Darwin:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/haskell-language-server/1.4.0/haskell-language-server-macOS-aarch64-1.4.0.tar.gz
+              dlHash: 70c6fe38e987ba44c1e19173486c01f666ffb30a74cd5a7968296a5aba4c2dd0
+        A_ARM:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/haskell-language-server/1.4.0/haskell-language-server-linux-armv7-1.4.0.tar.gz
+              dlHash: 4a921fbca06b02f3b1c0930cec5e65e9362b603e7715680ec7b150f18bd703d6
   Stack:
     2.5.1:
       viTags:

docs/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Revision history for ghcup
 
+## 0.1.17 -- 2021-09-20
+
+* Add `--force` option to install/compile wrt [#210](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/210) by Arjun Kathuria
+* Implement compiling HLS from source wrt [#201](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/201)
+* Implement experimental GPG verification of the metadata file (see README) wrt [#263](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/236)
+* Add `ghcup unset` command wrt [#145](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/145)
+* Add `ghcup whereis bindir` etc wrt [#221](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/221)
+* Greatly reduce dependency footprint wrt [#212](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/212)
+* Add `ghcup --plan-json`
+* Improve `--patchdir` option for GHC compilation wrt [#226](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/226)
+* Try to improve logging and failure modes, especially during downloads
+* Add descriptive warnings when HLS and GHC versions are incompatible
+* Improve curl header parsing wrt [#213](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/213)
+
 ## 0.1.16.2 -- 2021-08-12
 
 * Add isolated installations wrt [#141](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/141) by Arjun Kathuria

docs/RELEASING.md

@@ -0,0 +1,21 @@
+# RELEASING
+
+1. Update version in `ghcup.cabal` and `boostrap-haskell` (`ghver` variable at the top of the script)
+
+2. Update `GHCup.Version` module. `ghcupURL` must only be updated if we change the `GHCupInfo` type or the YAML representation of it. The version of the YAML represents the change increments. `ghcUpVer` is the current application version, read from `ghcup.cabal`.
+
+3. Add ChangeLog entry
+
+4. Add/fix downloads in `ghcup-<ver>.yaml` (under `data/metadata`), then verify with `ghcup-gen check -f ghcup-<ver>.yaml` and possibly (example only) `ghcup-gen check-tarballs -f ghcup-<ver>.yaml -u 'ghc-8.10.7'`. Generally, new GHC/cabal/stack/hls versions are only added to the latest yaml file. New GHCup versions are added to all (great care must be taken here to not break the parser... e.g. ARM platforms don't parse in all older formats).
+
+5. Commit and git push with tag. Wait for tests to succeed and release artifacts to build.
+
+6. Download release artifacts and upload them `downloads.haskell.org/ghcup` along with checksum files (`sha256sum --tag * > SHA256SUMS && gpg --detach-sign -u <your-email> SHA256SUMS`)
+
+7. Add ghcup release artifacts to ALL yaml files (see point 4.)
+
+8. Upload the final `ghcup-<ver>.yaml` to `webhost.haskell.org/ghcup/data/`.
+
+9. Update `bootstrap-haskell` and `bootstrap-haskell.ps1` to `webhost.haskell.org/ghcup/sh/`
+
+10. Update the ghcup symlinks at `downloads.haskell.org/ghcup`

ghcup.cabal

@@ -1,6 +1,6 @@
 cabal-version:   3.0
 name:            ghcup
-version:         0.1.16.2
+version:         0.1.17
 license:         LGPL-3.0-only
 license-file:    LICENSE
 copyright:       Julian Ospald 2020
@@ -16,14 +16,18 @@ description:
 category:        System
 build-type:      Simple
 extra-doc-files:
-  CHANGELOG.md
-  config.yaml
-  ghcup-0.0.4.yaml
-  ghcup-0.0.5.yaml
-  ghcup-0.0.6.yaml
-  HACKING.md
   README.md
-  RELEASING.md
+  docs/CHANGELOG.md
+  docs/HACKING.md
+  docs/RELEASING.md
+  data/config.yaml
+  data/metadata/ghcup-0.0.4.yaml
+  data/metadata/ghcup-0.0.5.yaml
+  data/metadata/ghcup-0.0.6.yaml
+
+extra-source-files:
+  data/build_mk/default
+  data/build_mk/cross
 
 source-repository head
   type:     git
@@ -43,11 +47,6 @@ flag internal-downloader
   default:     False
   manual:      True
 
-flag tar
-  description: Use tar-bytestring instead of libarchive.
-  default:     False
-  manual:      True
-
 library
   exposed-modules:
     GHCup
@@ -100,6 +99,7 @@ library
     , base16-bytestring     >=0.1.1.6    && <1.1
     , binary                ^>=0.8.6.0
     , bytestring            ^>=0.10
+    , Cabal
     , case-insensitive      ^>=1.2.1.0
     , casing                ^>=0.1.4.1
     , concurrent-output     ^>=1.10.11
@@ -108,19 +108,15 @@ library
     , deepseq               ^>=1.4.4.0
     , directory             ^>=1.3.6.0
     , disk-free-space       ^>=0.1.0.1
-    , extra                 ^>=1.7.9
     , filepath              ^>=1.4.2.1
-    , generics-sop          ^>=0.5
     , haskus-utils-types    ^>=1.5
     , haskus-utils-variant  >=3.0        && <3.2
+    , libarchive            ^>=3.0.0.0
     , lzma-static           ^>=5.2.5.3
     , megaparsec            >=8.0.0      && <9.1
-    , monad-logger          ^>=0.3.31
     , mtl                   ^>=2.2
     , optics                ^>=0.4
-    , optics-vl             ^>=0.2
     , os-release            ^>=1.0.0
-    , parsec                ^>=3.1
     , pretty                ^>=1.1.3.1
     , pretty-terminal       ^>=0.1.0.0
     , regex-posix           ^>=0.96
@@ -129,7 +125,6 @@ library
     , safe-exceptions       ^>=0.1
     , split                 ^>=0.2.3.4
     , strict-base           ^>=0.4
-    , string-interpolate    >=0.2.0.0    && <0.4
     , template-haskell      >=2.7        && <2.18
     , temporary             ^>=1.3
     , text                  ^>=1.2.4.0
@@ -138,12 +133,10 @@ library
     , unliftio-core         ^>=0.2.0.1
     , unordered-containers  ^>=0.2.10.0
     , uri-bytestring        ^>=0.3.2.2
-    , utf8-string           ^>=1.0
     , vector                ^>=0.12
     , versions              >=4.0.1      && <5.1
     , word8                 ^>=0.1.3
-    , yaml                  ^>=0.11.4.0
+    , HsYAML-aeson          ^>=0.2.0.0
-    , zip                   ^>=1.7.1
     , zlib                  ^>=0.6.2.2
 
   if (flag(internal-downloader) && !os(windows))
@@ -155,13 +148,6 @@ library
       , io-streams             >=1.5.2.1
       , terminal-progress-bar  >=0.4.1
 
-  if flag(tar)
-    cpp-options:   -DTAR
-    build-depends: tar
-
-  else
-    build-depends: libarchive ^>=3.0.0.0
-
   if os(windows)
     cpp-options:   -DIS_WINDOWS
     other-modules: GHCup.Utils.File.Windows
@@ -175,8 +161,6 @@ library
     other-modules: GHCup.Utils.File.Posix
     build-depends:
       , bz2              >=0.5.0.5 && <1.1
-      , hpath-posix      ^>=0.13.3
-      , process          ^>=1.6.9
       , unix             ^>=2.7
       , unix-bytestring  ^>=0.3.7.3
 
@@ -203,16 +187,19 @@ executable ghcup
     -fwarn-incomplete-record-updates -threaded
 
   build-depends:
+    , aeson                 >=1.4      && <1.6
+    , aeson-pretty          ^>=0.8.8
     , async                 ^>=2.2.3
     , base                  >=4.13     && <5
     , bytestring            ^>=0.10
+    , cabal-plan            ^>=0.7.2
     , containers            ^>=0.6
     , deepseq               ^>=1.4
     , filepath              ^>=1.4.2.1
     , ghcup
     , haskus-utils-variant  >=3.0      && <3.2
+    , libarchive            ^>=3.0.0.0
     , megaparsec            >=8.0.0    && <9.1
-    , monad-logger          ^>=0.3.31
     , mtl                   ^>=2.2
     , optparse-applicative  >=0.15.1.0 && <0.17
     , pretty                ^>=1.1.3.1
@@ -220,13 +207,12 @@ executable ghcup
     , resourcet             ^>=1.2.2
     , safe                  ^>=0.3.18
     , safe-exceptions       ^>=0.1
-    , string-interpolate    >=0.2.0.0  && <0.4
     , template-haskell      >=2.7      && <2.18
     , text                  ^>=1.2.4.0
     , uri-bytestring        ^>=0.3.2.2
     , utf8-string           ^>=1.0
     , versions              >=4.0.1    && <5.1
-    , yaml                  ^>=0.11.4.0
+    , HsYAML-aeson          ^>=0.2.0.0
 
   if flag(internal-downloader)
     cpp-options: -DINTERNAL_DOWNLOADER
@@ -235,7 +221,7 @@ executable ghcup
     cpp-options:   -DBRICK
     other-modules: BrickMain
     build-depends:
-      , brick         >=0.5    && <0.64
+      , brick         ^>=0.64
       , transformers  ^>=0.5
       , vector        ^>=0.12
       , vty           >=5.28.2 && <5.34
@@ -243,12 +229,6 @@ executable ghcup
   if os(windows)
     cpp-options: -DIS_WINDOWS
 
-  if flag(tar)
-    cpp-options: -DTAR
-
-  else
-    build-depends: libarchive ^>=3.0.0.0
-
 executable ghcup-gen
   main-is:            Main.hs
   hs-source-dirs:     app/ghcup-gen
@@ -280,7 +260,7 @@ executable ghcup-gen
     , filepath              ^>=1.4.2.1
     , ghcup
     , haskus-utils-variant  >=3.0      && <3.2
-    , monad-logger          ^>=0.3.31
+    , libarchive            ^>=3.0.0.0
     , mtl                   ^>=2.2
     , optics                ^>=0.4
     , optparse-applicative  >=0.15.1.0 && <0.17
@@ -289,19 +269,10 @@ executable ghcup-gen
     , regex-posix           ^>=0.96
     , resourcet             ^>=1.2.2
     , safe-exceptions       ^>=0.1
-    , string-interpolate    >=0.2.0.0  && <0.4
     , text                  ^>=1.2.4.0
     , transformers          ^>=0.5
-    , uri-bytestring        ^>=0.3.2.2
     , versions              >=4.0.1    && <5.1
-    , yaml                  ^>=0.11.4.0
+    , HsYAML-aeson          ^>=0.2.0.0
-
-  if flag(tar)
-    cpp-options:   -DTAR
-    build-depends: tar
-
-  else
-    build-depends: libarchive ^>=3.0.0.0
 
 test-suite ghcup-test
   type:               exitcode-stdio-1.0

lib/GHCup/Download.hs

@@ -1,10 +1,7 @@
 {-# LANGUAGE CPP                   #-}
 {-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE DeriveGeneric         #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE OverloadedStrings     #-}
-{-# LANGUAGE QuasiQuotes           #-}
-{-# LANGUAGE TemplateHaskell       #-}
 {-# LANGUAGE TypeApplications      #-}
 {-# LANGUAGE TypeFamilies          #-}
 
@@ -34,10 +31,11 @@ import           GHCup.Download.Utils
 #endif
 import           GHCup.Errors
 import           GHCup.Types
-import           GHCup.Types.JSON               ( )
 import           GHCup.Types.Optics
+import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.Dirs
 import           GHCup.Utils.File
+import           GHCup.Utils.Logger
 import           GHCup.Utils.Prelude
 import           GHCup.Version
 
@@ -47,7 +45,6 @@ import           Control.Monad
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
 #endif
-import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
                                          hiding ( throwM )
@@ -57,9 +54,8 @@ import           Data.ByteString                ( ByteString )
 #if defined(INTERNAL_DOWNLOADER)
 import           Data.CaseInsensitive           ( mk )
 #endif
-import           Data.List.Extra
 import           Data.Maybe
-import           Data.String.Interpolate
+import           Data.List
 import           Data.Time.Clock
 import           Data.Time.Clock.POSIX
 import           Data.Versions
@@ -73,6 +69,7 @@ import           Prelude                 hiding ( abs
                                                 , readFile
                                                 , writeFile
                                                 )
+import           Safe
 import           System.Directory
 import           System.Environment
 import           System.Exit
@@ -90,7 +87,7 @@ import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 import qualified Data.Text.IO                  as T
 import qualified Data.Text.Encoding            as E
-import qualified Data.Yaml                     as Y
+import qualified Data.YAML.Aeson               as Y
 
 
 
@@ -112,13 +109,13 @@ getDownloadsF :: ( FromJSONKey Tool
                  , HasDirs env
                  , MonadIO m
                  , MonadCatch m
-                 , MonadLogger m
+                 , HasLog env
                  , MonadThrow m
                  , MonadFail m
                  , MonadMask m
                  )
               => Excepts
-                   '[JSONError , DownloadFailed , FileDoesNotExistError]
+                   '[DigestError, GPGError, JSONError , DownloadFailed , FileDoesNotExistError]
                    m
                    GHCupInfo
 getDownloadsF = do
@@ -165,50 +162,58 @@ getBase :: ( MonadReader env m
            , MonadFail m
            , MonadIO m
            , MonadCatch m
-           , MonadLogger m
+           , HasLog env
            , MonadMask m
            )
         => URI
-        -> Excepts '[JSONError] m GHCupInfo
+        -> Excepts '[GPGError, DigestError, JSONError, FileDoesNotExistError] m GHCupInfo
 getBase uri = do
-  Settings { noNetwork } <- lift getSettings
+  Settings { noNetwork, downloader } <- lift getSettings
 
   -- try to download yaml... usually this writes it into cache dir,
   -- but in some cases not (e.g. when using file://), so we honour
   -- the return filepath, if any
   mYaml <- if noNetwork && view (uriSchemeL' % schemeBSL') uri /= "file" -- for file://, let it fall through
            then pure Nothing
-           else handleIO (\e -> warnCache (displayException e) >> pure Nothing)
+           else handleIO (\e -> lift (warnCache (displayException e) downloader) >> pure Nothing)
-               . catchE @_ @_ @'[] (\e@(DownloadFailed _) -> warnCache (prettyShow e) >> pure Nothing)
+               . catchE @_ @_ @'[] (\e@(DownloadFailed _) -> lift (warnCache (prettyShow e) downloader) >> pure Nothing)
-               . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed
                . fmap Just
                . smartDl
                $ uri
 
   -- if we didn't get a filepath from the download, use the cached yaml
   actualYaml <- maybe (lift $ yamlFromCache uri) pure mYaml
-  lift $ $(logDebug) [i|Decoding yaml at: #{actualYaml}|]
+  yamlContents <- liftIOException doesNotExistErrorType (FileDoesNotExistError actualYaml) $ liftIO $ L.readFile actualYaml
+  lift $ logDebug $ "Decoding yaml at: " <> T.pack actualYaml
 
   liftE
     . onE_ (onError actualYaml)
-    . lEM' @_ @_ @'[JSONError] JSONDecodeError
+    . lE' @_ @_ @'[JSONError] JSONDecodeError
-    . fmap (first (\e -> [i|#{displayException e}
+    . first (\(_, e) -> unlines [e, "Consider removing " <> actualYaml <> " manually."])
-Consider removing "#{actualYaml}" manually.|]))
+    . Y.decode1
-    . liftIO
+    $ yamlContents
-    . Y.decodeFileEither
-    $ actualYaml
  where
   -- On error, remove the etags file and set access time to 0. This should ensure the next invocation
   -- may re-download and succeed.
-  onError :: (MonadLogger m, MonadMask m, MonadCatch m, MonadIO m) => FilePath -> m ()
+  onError :: (MonadReader env m, HasLog env, MonadMask m, MonadCatch m, MonadIO m) => FilePath -> m ()
   onError fp = do
     let efp = etagsFile fp
-    handleIO (\e -> $(logWarn) [i|Couldn't remove file #{efp}, error was: #{displayException e}|])
+    handleIO (\e -> logWarn $ "Couldn't remove file " <> T.pack efp <> ", error was: " <> T.pack (displayException e))
       (hideError doesNotExistErrorType $ rmFile efp)
     liftIO $ hideError doesNotExistErrorType $ setAccessTime fp (posixSecondsToUTCTime (fromIntegral @Int 0))
-  warnCache s = do
+
-    lift $ $(logWarn) [i|Could not get download info, trying cached version (this may not be recent!)|]
+  warnCache :: (MonadReader env m, HasLog env, MonadMask m, MonadCatch m, MonadIO m) => FilePath -> Downloader -> m ()
-    lift $ $(logDebug) [i|Error was: #{s}|]
+  warnCache s downloader' = do
+    let tryDownloder = case downloader' of
+                         Curl -> "Wget"
+                         Wget -> "Curl"
+#if defined(INTERNAL_DOWNLOADER)
+                         Internal -> "Curl"
+#endif
+    logWarn $ "Could not get download info, trying cached version (this may not be recent!)" <> "\n" <>
+      "If this problem persists, consider switching downloader via: " <> "\n    " <>
+      "ghcup config set downloader " <> tryDownloder
+    logDebug $ "Error was: " <> T.pack s
 
   -- First check if the json file is in the ~/.ghcup/cache dir
   -- and check it's access time. If it has been accessed within the
@@ -222,13 +227,14 @@ Consider removing "#{actualYaml}" manually.|]))
              , MonadCatch m1
              , MonadIO m1
              , MonadFail m1
-             , MonadLogger m1
+             , HasLog env1
              , MonadMask m1
              )
           => URI
           -> Excepts
                '[ DownloadFailed
                 , DigestError
+                , GPGError
                 ]
                m1
                FilePath
@@ -240,7 +246,7 @@ Consider removing "#{actualYaml}" manually.|]))
     Dirs { cacheDir } <- lift getDirs
 
        -- for local files, let's short-circuit and ignore access time
-    if | scheme == "file" -> liftE $ download uri' Nothing cacheDir Nothing True
+    if | scheme == "file" -> liftE $ download uri' Nothing Nothing cacheDir Nothing True
        | e -> do
           accessTime <- liftIO $ getAccessTime json_file
 
@@ -253,7 +259,7 @@ Consider removing "#{actualYaml}" manually.|]))
    where
     dlWithMod modTime json_file = do
       let (dir, fn) = splitFileName json_file
-      f <- liftE $ download uri' Nothing dir (Just fn) True
+      f <- liftE $ download uri' (Just $ over pathL' (<> ".sig") uri') Nothing dir (Just fn) True
       liftIO $ setModificationTime f modTime
       liftIO $ setAccessTime f modTime
       pure f
@@ -313,21 +319,22 @@ download :: ( MonadReader env m
             , HasDirs env
             , MonadMask m
             , MonadThrow m
-            , MonadLogger m
+            , HasLog env
             , MonadIO m
             )
          => URI
+         -> Maybe URI         -- ^ URI for gpg sig
          -> Maybe T.Text      -- ^ expected hash
          -> FilePath          -- ^ destination dir (ignored for file:// scheme)
          -> Maybe FilePath    -- ^ optional filename
          -> Bool              -- ^ whether to read an write etags
-         -> Excepts '[DigestError , DownloadFailed] m FilePath
+         -> Excepts '[DigestError , DownloadFailed, GPGError] m FilePath
-download uri eDigest dest mfn etags
+download uri gpgUri eDigest dest mfn etags
   | scheme == "https" = dl
   | scheme == "http"  = dl
   | scheme == "file"  = do
-      let destFile' = T.unpack . decUTF8Safe $ path
+      let destFile' = T.unpack . decUTF8Safe $ view pathL' uri
-      lift $ $(logDebug) [i|using local file: #{destFile'}|]
+      lift $ logDebug $ "using local file: " <> T.pack destFile'
       forM_ eDigest (liftE . flip checkDigest destFile')
       pure destFile'
   | otherwise = throwE $ DownloadFailed (variantFromValue UnsupportedScheme)
@@ -335,143 +342,207 @@ download uri eDigest dest mfn etags
  where
   scheme = view (uriSchemeL' % schemeBSL') uri
   dl = do
-    destFile <- liftE . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed $ getDestFile
+    baseDestFile <- liftE . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed $ getDestFile uri mfn
-    lift $ $(logInfo) [i|downloading: #{uri'} as file #{destFile}|]
+    lift $ logInfo $ "downloading: " <> (decUTF8Safe . serializeURIRef') uri <> " as file " <> T.pack baseDestFile
 
     -- destination dir must exist
     liftIO $ createDirRecursive' dest
 
+
     -- download
     flip onException
-         (lift $ hideError doesNotExistErrorType $ recycleFile destFile)
+         (lift $ hideError doesNotExistErrorType $ recycleFile (tmpFile baseDestFile))
-     $ catchAllE @_ @'[ProcessError, DownloadFailed, UnsupportedScheme]
+     $ catchAllE @_ @'[GPGError, ProcessError, DownloadFailed, UnsupportedScheme, DigestError] @'[DigestError, DownloadFailed, GPGError]
-          (\e ->
+          (\e' -> do
-            lift (hideError doesNotExistErrorType $ recycleFile destFile)
+            lift $ hideError doesNotExistErrorType $ recycleFile (tmpFile baseDestFile)
-              >> (throwE . DownloadFailed $ e)
+            case e' of
+              V e@GPGError {} -> throwE e
+              V e@DigestError {} -> throwE e
+              _ -> throwE (DownloadFailed e')
           ) $ do
-              Settings{ downloader, noNetwork } <- lift getSettings
+              Settings{ downloader, noNetwork, gpgSetting } <- lift getSettings
               when noNetwork $ throwE (DownloadFailed (V NoNetwork :: V '[NoNetwork]))
-              case downloader of
+              downloadAction <- case downloader of
-                Curl -> do
+                    Curl -> do
-                  o' <- liftIO getCurlOpts
+                      o' <- liftIO getCurlOpts
-                  if etags
+                      if etags
-                    then do
+                        then pure $ curlEtagsDL o'
-                      dh <- liftIO $ emptySystemTempFile "curl-header"
+                        else pure $ curlDL o'
-                      flip finally (try @_ @SomeException $ rmFile dh) $
+                    Wget -> do
-                        flip finally (try @_ @SomeException $ rmFile (destFile <.> "tmp")) $ do
+                      o' <- liftIO getWgetOpts
-                          metag <- readETag destFile
+                      if etags
-                          liftE $ lEM @_ @'[ProcessError] $ exec "curl"
+                        then pure $ wgetEtagsDL o'
-                              (o' ++ (if etags then ["--dump-header", dh] else [])
+                        else pure $ wgetDL o'
-                                  ++ maybe [] (\t -> ["-H", [i|If-None-Match: #{t}|]]) metag
-                                  ++ ["-fL", "-o", destFile <.> "tmp", T.unpack uri']) Nothing Nothing
-                          headers <- liftIO $ T.readFile dh
-
-                          -- this nonsense is necessary, because some older versions of curl would overwrite
-                          -- the destination file when 304 is returned
-                          case fmap T.words . listToMaybe . fmap T.strip . T.lines . getLastHeader $ headers of
-                            Just (http':sc:_)
-                              | sc == "304"
-                              , T.pack "HTTP" `T.isPrefixOf` http' -> $logDebug [i|Status code was 304, not overwriting|]
-                              | T.pack "HTTP" `T.isPrefixOf` http' -> do
-                                  $logDebug [i|Status code was #{sc}, overwriting|]
-                                  liftIO $ copyFile (destFile <.> "tmp") destFile
-                            _ -> liftE $ throwE @_ @'[DownloadFailed] (DownloadFailed (toVariantAt @0 (MalformedHeaders headers)
-                              :: V '[MalformedHeaders]))
-
-                          writeEtags destFile (parseEtags headers)
-                    else
-                      liftE $ lEM @_ @'[ProcessError] $ exec "curl" 
-                        (o' ++ ["-fL", "-o", destFile, T.unpack uri']) Nothing Nothing
-                Wget -> do
-                  destFileTemp <- liftIO $ emptySystemTempFile "wget-tmp"
-                  flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
-                    o' <- liftIO getWgetOpts
-                    if etags
-                      then do
-                        metag <- readETag destFile
-                        let opts = o' ++ maybe [] (\t -> ["--header", [i|If-None-Match: #{t}|]]) metag
-                                      ++ ["-q", "-S", "-O", destFileTemp , T.unpack uri']
-                        CapturedProcess {_exitCode, _stdErr} <- lift $ executeOut "wget" opts Nothing
-                        case _exitCode of
-                          ExitSuccess -> do
-                            liftIO $ copyFile destFileTemp destFile
-                            writeEtags destFile (parseEtags (decUTF8Safe' _stdErr))
-                          ExitFailure i'
-                            | i' == 8
-                            , Just _ <- find (T.pack "304 Not Modified" `T.isInfixOf`) . T.lines . decUTF8Safe' $ _stdErr
-                                     -> do
-                                          $logDebug "Not modified, skipping download"
-                                          writeEtags destFile (parseEtags (decUTF8Safe' _stdErr))
-                            | otherwise -> throwE (NonZeroExit i' "wget" opts)
-                      else do
-                        let opts = o' ++ ["-O", destFileTemp , T.unpack uri']
-                        liftE $ lEM @_ @'[ProcessError] $ exec "wget" opts Nothing Nothing
-                        liftIO $ copyFile destFileTemp destFile
 #if defined(INTERNAL_DOWNLOADER)
-                Internal -> do
+                    Internal -> do
-                  (https, host, fullPath, port) <- liftE $ uriToQuadruple uri
+                      if etags
-                  if etags
+                        then pure (\fp -> liftE . internalEtagsDL fp)
-                    then do
+                        else pure (\fp -> liftE . internalDL fp)
-                      metag <- readETag destFile
-                      let addHeaders = maybe mempty (\etag -> M.fromList [ (mk . E.encodeUtf8 . T.pack $ "If-None-Match"
-                                                                         , E.encodeUtf8 etag)]) metag
-                      liftE
-                        $ catchE @HTTPNotModified @'[DownloadFailed] @'[] (\(HTTPNotModified etag) -> lift $ writeEtags destFile (pure $ Just etag))
-                        $ do
-                          r <- downloadToFile https host fullPath port destFile addHeaders
-                          writeEtags destFile (pure $ decUTF8Safe <$> getHeader r "etag")
-                    else void $ liftE $ catchE @HTTPNotModified
-                                        @'[DownloadFailed]
-                                   (\e@(HTTPNotModified _) ->
-                                     throwE @_ @'[DownloadFailed] (DownloadFailed (toVariantAt @0 e :: V '[HTTPNotModified])))
-                               $ downloadToFile https host fullPath port destFile mempty
 #endif
+              liftE $ downloadAction baseDestFile uri
+              case (gpgUri, gpgSetting) of
+                (_, GPGNone) -> pure ()
+                (Just gpgUri', _) -> do
+                  gpgDestFile <- liftE . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed $ getDestFile gpgUri' Nothing
+                  liftE $ flip onException
+                       (lift $ hideError doesNotExistErrorType $ recycleFile (tmpFile gpgDestFile))
+                   $ catchAllE @_ @'[GPGError, ProcessError, UnsupportedScheme, DownloadFailed] @'[GPGError]
+                        (\e -> if gpgSetting == GPGStrict then throwE (GPGError e) else lift $ logWarn $ T.pack (prettyShow (GPGError e))
+                        ) $ do
+                      o' <- liftIO getGpgOpts
+                      lift $ logDebug $ "downloading: " <> (decUTF8Safe . serializeURIRef') gpgUri' <> " as file " <> T.pack gpgDestFile
+                      liftE $ downloadAction gpgDestFile gpgUri'
+                      lift $ logInfo $ "verifying signature of: " <> T.pack baseDestFile
+                      let args = o' ++ ["--batch", "--verify", "--quiet", "--no-tty", gpgDestFile, baseDestFile]
+                      cp <- lift $ executeOut "gpg" args Nothing
+                      case cp of
+                        CapturedProcess { _exitCode = ExitFailure i, _stdErr } -> do
+                          lift $ logDebug $ decUTF8Safe' _stdErr
+                          throwE (GPGError @'[ProcessError] (V (NonZeroExit i "gpg" args)))
+                        CapturedProcess { _stdErr } -> lift $ logDebug $ decUTF8Safe' _stdErr
+                _ -> pure ()
 
-    forM_ eDigest (liftE . flip checkDigest destFile)
+              forM_ eDigest (liftE . flip checkDigest baseDestFile)
-    pure destFile
+    pure baseDestFile
+
+  curlDL :: (MonadCatch m, MonadMask m, MonadIO m) => [String] -> FilePath -> URI -> Excepts '[ProcessError, DownloadFailed, UnsupportedScheme] m ()
+  curlDL o' destFile (decUTF8Safe . serializeURIRef' -> uri') = do
+    let destFileTemp = tmpFile destFile
+    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
+      liftE $ lEM @_ @'[ProcessError] $ exec "curl"
+        (o' ++ ["-fL", "-o", destFileTemp, T.unpack uri']) Nothing Nothing
+      liftIO $ renameFile destFileTemp destFile
+
+  curlEtagsDL :: (MonadReader env m, HasLog env, MonadCatch m, MonadMask m, MonadIO m)
+              => [String] -> FilePath -> URI -> Excepts '[ProcessError, DownloadFailed, UnsupportedScheme] m ()
+  curlEtagsDL o' destFile (decUTF8Safe . serializeURIRef' -> uri') = do
+    let destFileTemp = tmpFile destFile
+    dh <- liftIO $ emptySystemTempFile "curl-header"
+    flip finally (try @_ @SomeException $ rmFile dh) $
+      flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
+        metag <- lift $ readETag destFile
+        liftE $ lEM @_ @'[ProcessError] $ exec "curl"
+            (o' ++ (if etags then ["--dump-header", dh] else [])
+                ++ maybe [] (\t -> ["-H", "If-None-Match: " <> T.unpack t]) metag
+                ++ ["-fL", "-o", destFileTemp, T.unpack uri']) Nothing Nothing
+        headers <- liftIO $ T.readFile dh
+
+        -- this nonsense is necessary, because some older versions of curl would overwrite
+        -- the destination file when 304 is returned
+        case fmap T.words . listToMaybe . fmap T.strip . T.lines . getLastHeader $ headers of
+          Just (http':sc:_)
+            | sc == "304"
+            , T.pack "HTTP" `T.isPrefixOf` http' -> lift $ logDebug "Status code was 304, not overwriting"
+            | T.pack "HTTP" `T.isPrefixOf` http' -> do
+                lift $ logDebug $ "Status code was " <> sc <> ", overwriting"
+                liftIO $ renameFile destFileTemp destFile
+          _ -> liftE $ throwE @_ @'[DownloadFailed] (DownloadFailed (toVariantAt @0 (MalformedHeaders headers)
+            :: V '[MalformedHeaders]))
+
+        lift $ writeEtags destFile (parseEtags headers)
+
+  wgetDL :: (MonadCatch m, MonadMask m, MonadIO m) => [String] -> FilePath -> URI -> Excepts '[ProcessError, DownloadFailed, UnsupportedScheme] m ()
+  wgetDL o' destFile (decUTF8Safe . serializeURIRef' -> uri') = do
+    let destFileTemp = tmpFile destFile
+    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
+      let opts = o' ++ ["-O", destFileTemp , T.unpack uri']
+      liftE $ lEM @_ @'[ProcessError] $ exec "wget" opts Nothing Nothing
+      liftIO $ renameFile destFileTemp destFile
+
+
+  wgetEtagsDL :: (MonadReader env m, HasLog env, MonadCatch m, MonadMask m, MonadIO m)
+              => [String] -> FilePath -> URI -> Excepts '[ProcessError, DownloadFailed, UnsupportedScheme] m ()
+  wgetEtagsDL o' destFile (decUTF8Safe . serializeURIRef' -> uri') = do
+    let destFileTemp = tmpFile destFile
+    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
+      metag <- lift $ readETag destFile
+      let opts = o' ++ maybe [] (\t -> ["--header", "If-None-Match: " <> T.unpack t]) metag
+                    ++ ["-q", "-S", "-O", destFileTemp , T.unpack uri']
+      CapturedProcess {_exitCode, _stdErr} <- lift $ executeOut "wget" opts Nothing
+      case _exitCode of
+        ExitSuccess -> do
+          liftIO $ renameFile destFileTemp destFile
+          lift $ writeEtags destFile (parseEtags (decUTF8Safe' _stdErr))
+        ExitFailure i'
+          | i' == 8
+          , Just _ <- find (T.pack "304 Not Modified" `T.isInfixOf`) . T.lines . decUTF8Safe' $ _stdErr
+                   -> do
+                        lift $ logDebug "Not modified, skipping download"
+                        lift $ writeEtags destFile (parseEtags (decUTF8Safe' _stdErr))
+          | otherwise -> throwE (NonZeroExit i' "wget" opts)
+
+#if defined(INTERNAL_DOWNLOADER)
+  internalDL :: (MonadCatch m, MonadMask m, MonadIO m)
+             => FilePath -> URI -> Excepts '[DownloadFailed, UnsupportedScheme] m ()
+  internalDL destFile uri' = do
+    let destFileTemp = tmpFile destFile
+    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
+      (https, host, fullPath, port) <- liftE $ uriToQuadruple uri'
+      void $ liftE $ catchE @HTTPNotModified
+                 @'[DownloadFailed]
+            (\e@(HTTPNotModified _) ->
+              throwE @_ @'[DownloadFailed] (DownloadFailed (toVariantAt @0 e :: V '[HTTPNotModified])))
+        $ downloadToFile https host fullPath port destFileTemp mempty
+      liftIO $ renameFile destFileTemp destFile
+
+
+  internalEtagsDL :: (MonadReader env m, HasLog env, MonadCatch m, MonadMask m, MonadIO m)
+                  => FilePath -> URI -> Excepts '[DownloadFailed, UnsupportedScheme] m ()
+  internalEtagsDL destFile uri' = do
+    let destFileTemp = tmpFile destFile
+    flip finally (try @_ @SomeException $ rmFile destFileTemp) $ do
+      (https, host, fullPath, port) <- liftE $ uriToQuadruple uri'
+      metag <- lift $ readETag destFile
+      let addHeaders = maybe mempty (\etag -> M.fromList [ (mk . E.encodeUtf8 . T.pack $ "If-None-Match"
+                                                         , E.encodeUtf8 etag)]) metag
+      liftE
+        $ catchE @HTTPNotModified @'[DownloadFailed] @'[] (\(HTTPNotModified etag) -> lift $ writeEtags destFile (pure $ Just etag))
+        $ do
+          r <- downloadToFile https host fullPath port destFileTemp addHeaders
+          liftIO $ renameFile destFileTemp destFile
+          lift $ writeEtags destFile (pure $ decUTF8Safe <$> getHeader r "etag")
+#endif
 
 
   -- Manage to find a file we can write the body into.
-  getDestFile :: Monad m => Excepts '[NoUrlBase] m FilePath
+  getDestFile :: Monad m => URI -> Maybe FilePath -> Excepts '[NoUrlBase] m FilePath
-  getDestFile = 
+  getDestFile uri' mfn' = 
-    case mfn of
+    let path = view pathL' uri'
+    in case mfn' of
         Just fn -> pure (dest </> fn)
         Nothing
           | let urlBase = T.unpack (decUTF8Safe (urlBaseName path))
           , not (null urlBase) -> pure (dest </> urlBase)
           -- TODO: remove this once we use hpath again
-          | otherwise -> throwE $ NoUrlBase uri'
+          | otherwise -> throwE $ NoUrlBase (decUTF8Safe . serializeURIRef' $ uri')
 
-  path = view pathL' uri
+  parseEtags :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m) => T.Text -> m (Maybe T.Text)
-  uri' = decUTF8Safe (serializeURIRef' uri)
-
-  parseEtags :: (MonadLogger m, MonadIO m, MonadThrow m) => T.Text -> m (Maybe T.Text)
   parseEtags stderr = do
     let mEtag = find (\line -> T.pack "etag:" `T.isPrefixOf` T.toLower line) . fmap T.strip . T.lines . getLastHeader $ stderr
     case T.words <$> mEtag of
       (Just []) -> do
-        $logDebug "Couldn't parse etags, no input: "
+        logDebug "Couldn't parse etags, no input: "
         pure Nothing
       (Just [_, etag']) -> do
-        $logDebug [i|Parsed etag: #{etag'}|]
+        logDebug $ "Parsed etag: " <> etag'
         pure (Just etag')
       (Just xs) -> do
-        $logDebug ("Couldn't parse etags, unexpected input: " <> T.unwords xs)
+        logDebug ("Couldn't parse etags, unexpected input: " <> T.unwords xs)
         pure Nothing
       Nothing -> do
-        $logDebug "No etags header found"
+        logDebug "No etags header found"
         pure Nothing
 
-  writeEtags :: (MonadLogger m, MonadIO m, MonadThrow m) => FilePath -> m (Maybe T.Text) -> m ()
+  writeEtags :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m) => FilePath -> m (Maybe T.Text) -> m ()
   writeEtags destFile getTags = do
     getTags >>= \case
       Just t -> do
-        $logDebug [i|Writing etagsFile #{(etagsFile destFile)}|]
+        logDebug $ "Writing etagsFile " <> T.pack (etagsFile destFile)
         liftIO $ T.writeFile (etagsFile destFile) t
       Nothing ->
-        $logDebug [i|No etags files written|]
+        logDebug "No etags files written"
 
-  readETag :: (MonadLogger m, MonadCatch m, MonadIO m) => FilePath -> m (Maybe T.Text)
+  readETag :: (MonadReader env m, HasLog env, MonadCatch m, MonadIO m) => FilePath -> m (Maybe T.Text)
   readETag fp = do
     e <- liftIO $ doesFileExist fp
     if e
@@ -479,13 +550,13 @@ download uri eDigest dest mfn etags
       rE <- try @_ @SomeException $ liftIO $ fmap stripNewline' $ T.readFile (etagsFile fp)
       case rE of
         (Right et) -> do
-          $logDebug [i|Read etag: #{et}|]
+          logDebug $ "Read etag: " <> et
           pure (Just et)
         (Left _) -> do
-          $logDebug [i|Etag file doesn't exist (yet)|]
+          logDebug "Etag file doesn't exist (yet)"
           pure Nothing
     else do
-      $logDebug [i|Skipping and deleting etags file because destination file #{fp} doesn't exist|]
+      logDebug $ "Skipping and deleting etags file because destination file " <> T.pack fp <> " doesn't exist"
       liftIO $ hideError doesNotExistErrorType $ rmFile (etagsFile fp)
       pure Nothing
 
@@ -498,20 +569,20 @@ downloadCached :: ( MonadReader env m
                   , MonadMask m
                   , MonadResource m
                   , MonadThrow m
-                  , MonadLogger m
+                  , HasLog env
                   , MonadIO m
                   , MonadUnliftIO m
                   )
                => DownloadInfo
                -> Maybe FilePath  -- ^ optional filename
-               -> Excepts '[DigestError , DownloadFailed] m FilePath
+               -> Excepts '[DigestError , DownloadFailed, GPGError] m FilePath
 downloadCached dli mfn = do
   Settings{ cache } <- lift getSettings
   case cache of
     True -> downloadCached' dli mfn Nothing
     False -> do
       tmp <- lift withGHCupTmpDir
-      liftE $ download (_dlUri dli) (Just (_dlHash dli)) tmp mfn False
+      liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) tmp mfn False
 
 
 downloadCached' :: ( MonadReader env m
@@ -519,14 +590,14 @@ downloadCached' :: ( MonadReader env m
                    , HasSettings env
                    , MonadMask m
                    , MonadThrow m
-                   , MonadLogger m
+                   , HasLog env
                    , MonadIO m
                    , MonadUnliftIO m
                    )
                 => DownloadInfo
                 -> Maybe FilePath  -- ^ optional filename
                 -> Maybe FilePath  -- ^ optional destination dir (default: cacheDir)
-                -> Excepts '[DigestError , DownloadFailed] m FilePath
+                -> Excepts '[DigestError , DownloadFailed, GPGError] m FilePath
 downloadCached' dli mfn mDestDir = do
   Dirs { cacheDir } <- lift getDirs
   let destDir = fromMaybe cacheDir mDestDir
@@ -537,7 +608,7 @@ downloadCached' dli mfn mDestDir = do
     | fileExists -> do
       liftE $ checkDigest (view dlHash dli) cachfile
       pure cachfile
-    | otherwise -> liftE $ download (_dlUri dli) (Just (_dlHash dli)) destDir mfn False
+    | otherwise -> liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) destDir mfn False
 
 
 
@@ -553,7 +624,7 @@ checkDigest :: ( MonadReader env m
                , HasSettings env
                , MonadIO m
                , MonadThrow m
-               , MonadLogger m
+               , HasLog env
                )
             => T.Text     -- ^ the hash
             -> FilePath
@@ -563,10 +634,10 @@ checkDigest eDigest file = do
   let verify = not noVerify
   when verify $ do
     let p' = takeFileName file
-    lift $ $(logInfo) [i|verifying digest of: #{p'}|]
+    lift $ logInfo $ "verifying digest of: " <> T.pack p'
     c <- liftIO $ L.readFile file
     cDigest <- throwEither . E.decodeUtf8' . B16.encode . SHA256.hashlazy $ c
-    when ((cDigest /= eDigest) && verify) $ throwE (DigestError cDigest eDigest)
+    when ((cDigest /= eDigest) && verify) $ throwE (DigestError file cDigest eDigest)
 
 
 -- | Get additional curl args from env. This is an undocumented option.
@@ -584,6 +655,12 @@ getWgetOpts =
     Just r  -> pure $ splitOn " " r
     Nothing -> pure []
 
+-- | Get additional gpg args from env. This is an undocumented option.
+getGpgOpts :: IO [String]
+getGpgOpts =
+  lookupEnv "GHCUP_GPG_OPTS" >>= \case
+    Just r  -> pure $ splitOn " " r
+    Nothing -> pure []
 
 -- | Get the url base name.
 --
@@ -605,3 +682,7 @@ urlBaseName = snd . B.breakEnd (== _slash) . urlDecode False
 -- "HTTP/1.1 304 Not Modified\n"
 getLastHeader :: T.Text -> T.Text
 getLastHeader = T.unlines . lastDef [] . filter (\x -> not (null x)) . splitOn [""] . fmap T.stripEnd . T.lines
+
+
+tmpFile :: FilePath -> FilePath
+tmpFile = (<.> "tmp")

lib/GHCup/Errors.hs

@@ -4,7 +4,6 @@
 {-# LANGUAGE ExistentialQuantification #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE TypeOperators           #-}
 {-# LANGUAGE FlexibleInstances           #-}
 
@@ -21,15 +20,10 @@ module GHCup.Errors where
 
 import           GHCup.Types
 
-#if !defined(TAR)
 import           Codec.Archive
-#else
-import qualified Codec.Archive.Tar             as Tar
-#endif
 import           Control.Exception.Safe
 import           Data.ByteString                ( ByteString )
 import           Data.CaseInsensitive           ( CI )
-import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           Haskus.Utils.Variant
@@ -38,6 +32,7 @@ import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
 import           URI.ByteString
 
 import qualified Data.Map.Strict               as M
+import qualified Data.Text                     as T
 
 
 
@@ -55,7 +50,7 @@ instance Pretty NoCompatiblePlatform where
   pPrint (NoCompatiblePlatform str') =
     text ("Could not find a compatible platform. Got: " ++ str')
 
--- | Unable to find a download for the requested versio/distro.
+-- | Unable to find a download for the requested version/distro.
 data NoDownload = NoDownload
   deriving Show
 
@@ -92,7 +87,7 @@ data UnknownArchive = UnknownArchive FilePath
 
 instance Pretty UnknownArchive where
   pPrint (UnknownArchive file) =
-    text [i|The archive format is unknown. We don't know how to extract the file "#{file}"|]
+    text $ "The archive format is unknown. We don't know how to extract the file " <> file
 
 -- | The scheme is not supported (such as ftp).
 data UnsupportedScheme = UnsupportedScheme
@@ -115,7 +110,7 @@ data TagNotFound = TagNotFound Tag Tool
 
 instance Pretty TagNotFound where
   pPrint (TagNotFound tag tool) =
-    text "Unable to find tag" <+> pPrint tag <+> text [i|of tool "#{tool}"|]
+    text "Unable to find tag" <+> pPrint tag <+> text "of tool" <+> pPrint tool
 
 -- | Unable to find the next version of a tool (the one after the currently
 -- set one).
@@ -124,7 +119,7 @@ data NextVerNotFound = NextVerNotFound Tool
 
 instance Pretty NextVerNotFound where
   pPrint (NextVerNotFound tool) =
-    text [i|Unable to find next (the one after the currently set one) version of tool "#{tool}"|]
+    text "Unable to find next (the one after the currently set one) version of tool" <+> pPrint tool
 
 -- | The tool (such as GHC) is already installed with that version.
 data AlreadyInstalled = AlreadyInstalled Tool Version
@@ -132,14 +127,14 @@ data AlreadyInstalled = AlreadyInstalled Tool Version
 
 instance Pretty AlreadyInstalled where
   pPrint (AlreadyInstalled tool ver') =
-    text [i|#{tool}-#{prettyShow ver'} is already installed|]
+    pPrint tool <+> text "-" <+> pPrint ver' <+> text "is already installed"
 
 -- | The Directory is supposed to be empty, but wasn't.
 data DirNotEmpty = DirNotEmpty {path :: FilePath}
 
 instance Pretty DirNotEmpty where
   pPrint (DirNotEmpty path) = do
-    text [i|The directory was expected to be empty, but isn't: #{path}|]
+    text $ "The directory was expected to be empty, but isn't: " <> path
 
 -- | The tool is not installed. Some operations rely on a tool
 -- to be installed (such as setting the current GHC version).
@@ -148,7 +143,7 @@ data NotInstalled = NotInstalled Tool GHCTargetVersion
 
 instance Pretty NotInstalled where
   pPrint (NotInstalled tool ver) =
-    text [i|The version "#{prettyShow ver}" of the tool "#{tool}" is not installed.|]
+    text "The version" <+> pPrint ver <+> text "of the tool" <+> pPrint tool <+> text "is not installed."
 
 -- | An executable was expected to be in PATH, but was not found.
 data NotFoundInPATH = NotFoundInPATH FilePath
@@ -156,7 +151,7 @@ data NotFoundInPATH = NotFoundInPATH FilePath
 
 instance Pretty NotFoundInPATH where
   pPrint (NotFoundInPATH exe) =
-    text [i|The exe "#{exe}" was not found in PATH.|]
+    text $ "The exe " <> exe <> " was not found in PATH."
 
 -- | JSON decoding failed.
 data JSONError = JSONDecodeError String
@@ -164,7 +159,7 @@ data JSONError = JSONDecodeError String
 
 instance Pretty JSONError where
   pPrint (JSONDecodeError err) =
-    text [i|JSON decoding failed with: #{err}|]
+    text $ "JSON decoding failed with: " <> err
 
 -- | A file that is supposed to exist does not exist
 -- (e.g. when we use file scheme to "download" something).
@@ -173,7 +168,7 @@ data FileDoesNotExistError = FileDoesNotExistError FilePath
 
 instance Pretty FileDoesNotExistError where
   pPrint (FileDoesNotExistError file) =
-    text [i|File "#{file}" does not exist.|]
+    text $ "File " <> file <> " does not exist."
 
 -- | The file already exists
 -- (e.g. when we use isolated installs with the same path).
@@ -183,7 +178,7 @@ data FileAlreadyExistsError = FileAlreadyExistsError FilePath
 
 instance Pretty FileAlreadyExistsError where
   pPrint (FileAlreadyExistsError file) =
-    text [i|File "#{file}" Already exists.|]
+    text $ "File " <> file <> " Already exists."
 
 data TarDirDoesNotExist = TarDirDoesNotExist TarDir
   deriving Show
@@ -193,12 +188,22 @@ instance Pretty TarDirDoesNotExist where
     text "Tar directory does not exist:" <+> pPrint dir
 
 -- | File digest verification failed.
-data DigestError = DigestError Text Text
+data DigestError = DigestError FilePath Text Text
   deriving Show
 
 instance Pretty DigestError where
-  pPrint (DigestError currentDigest expectedDigest) =
+  pPrint (DigestError fp currentDigest expectedDigest) =
-    text [i|Digest error: expected "#{expectedDigest}", but got "#{currentDigest}"|]
+    text "Digest error for" <+> text (fp <> ": expected")
+      <+> text (T.unpack expectedDigest) <+> text "but got" <+> pPrint currentDigest <+> text
+      "\nConsider removing the file in case it's cached and try again."
+
+-- | File digest verification failed.
+data GPGError = forall xs . (ToVariantMaybe DownloadFailed xs, PopVariant DownloadFailed xs, Show (V xs), Pretty (V xs)) => GPGError (V xs)
+
+deriving instance Show GPGError
+
+instance Pretty GPGError where
+  pPrint (GPGError reason) = text "GPG verify failed:" <+> pPrint reason
 
 -- | Unexpected HTTP status.
 data HTTPStatusError = HTTPStatusError Int (M.Map (CI ByteString) ByteString)
@@ -206,7 +211,7 @@ data HTTPStatusError = HTTPStatusError Int (M.Map (CI ByteString) ByteString)
 
 instance Pretty HTTPStatusError where
   pPrint (HTTPStatusError status _) =
-    text [i|Unexpected HTTP status: #{status}|]
+    text "Unexpected HTTP status:" <+> pPrint status
 
 -- | Malformed headers.
 data MalformedHeaders = MalformedHeaders Text
@@ -214,7 +219,7 @@ data MalformedHeaders = MalformedHeaders Text
 
 instance Pretty MalformedHeaders where
   pPrint (MalformedHeaders h) =
-    text [i|Headers are malformed: #{h}|]
+    text "Headers are malformed: " <+> pPrint h
 
 -- | Unexpected HTTP status.
 data HTTPNotModified = HTTPNotModified Text
@@ -222,7 +227,7 @@ data HTTPNotModified = HTTPNotModified Text
 
 instance Pretty HTTPNotModified where
   pPrint (HTTPNotModified etag) =
-    text [i|Remote resource not modifed, etag was: #{etag}|]
+    text "Remote resource not modifed, etag was:" <+> pPrint etag
 
 -- | The 'Location' header was expected during a 3xx redirect, but not found.
 data NoLocationHeader = NoLocationHeader
@@ -230,7 +235,7 @@ data NoLocationHeader = NoLocationHeader
 
 instance Pretty NoLocationHeader where
   pPrint NoLocationHeader =
-    text [i|The 'Location' header was expected during a 3xx redirect, but not found.|]
+    text "The 'Location' header was expected during a 3xx redirect, but not found."
 
 -- | Too many redirects.
 data TooManyRedirs = TooManyRedirs
@@ -238,7 +243,7 @@ data TooManyRedirs = TooManyRedirs
 
 instance Pretty TooManyRedirs where
   pPrint TooManyRedirs =
-    text [i|Too many redirections.|]
+    text "Too many redirections."
 
 -- | A patch could not be applied.
 data PatchFailed = PatchFailed
@@ -246,7 +251,7 @@ data PatchFailed = PatchFailed
 
 instance Pretty PatchFailed where
   pPrint PatchFailed =
-    text [i|A patch could not be applied.|]
+    text "A patch could not be applied."
 
 -- | The tool requirements could not be found.
 data NoToolRequirements = NoToolRequirements
@@ -254,35 +259,35 @@ data NoToolRequirements = NoToolRequirements
 
 instance Pretty NoToolRequirements where
   pPrint NoToolRequirements =
-    text [i|The Tool requirements could not be found.|]
+    text "The Tool requirements could not be found."
 
 data InvalidBuildConfig = InvalidBuildConfig Text
   deriving Show
 
 instance Pretty InvalidBuildConfig where
   pPrint (InvalidBuildConfig reason) =
-    text [i|The build config is invalid. Reason was: #{reason}|]
+    text "The build config is invalid. Reason was:" <+> pPrint reason
 
 data NoToolVersionSet = NoToolVersionSet Tool
   deriving Show
 
 instance Pretty NoToolVersionSet where
   pPrint (NoToolVersionSet tool) =
-    text [i|No version is set for tool "#{tool}".|]
+    text "No version is set for tool" <+> pPrint tool <+> text "."
 
 data NoNetwork = NoNetwork
   deriving Show
 
 instance Pretty NoNetwork where
   pPrint NoNetwork =
-    text [i|A download was required or requested, but '--offline' was specified.|]
+    text "A download was required or requested, but '--offline' was specified."
 
 data HadrianNotFound = HadrianNotFound
   deriving Show
 
 instance Pretty HadrianNotFound where
   pPrint HadrianNotFound =
-    text [i|Could not find Hadrian build files. Does this GHC version support Hadrian builds?|]
+    text "Could not find Hadrian build files. Does this GHC version support Hadrian builds?"
 
 
     -------------------------
@@ -290,31 +295,37 @@ instance Pretty HadrianNotFound where
     -------------------------
 
 -- | A download failed. The underlying error is encapsulated.
-data DownloadFailed = forall x xs . (Show x, Show (V xs), Pretty x, Pretty (V xs)) => DownloadFailed (V (x ': xs))
+data DownloadFailed = forall xs . (ToVariantMaybe DownloadFailed xs, PopVariant DownloadFailed xs, Show (V xs), Pretty (V xs)) => DownloadFailed (V xs)
 
 instance Pretty DownloadFailed where
   pPrint (DownloadFailed reason) =
-    text "Download failed:" <+> pPrint reason
+    case reason of
+      VMaybe (_ :: DownloadFailed) -> pPrint reason
+      _ -> text "Download failed:" <+> pPrint reason
 
 deriving instance Show DownloadFailed
 
 
 -- | A build failed.
-data BuildFailed = forall es . (Pretty (V es), Show (V es)) => BuildFailed FilePath (V es)
+data BuildFailed = forall es . (ToVariantMaybe BuildFailed es, PopVariant BuildFailed es, Pretty (V es), Show (V es)) => BuildFailed FilePath (V es)
 
 instance Pretty BuildFailed where
   pPrint (BuildFailed path reason) =
-    text [i|BuildFailed failed in dir "#{path}": |] <> pPrint reason
+    case reason of
+      VMaybe (_ :: BuildFailed) -> pPrint reason
+      _ -> text "BuildFailed failed in dir" <+> text (path <> ":") <+> pPrint reason
 
 deriving instance Show BuildFailed
 
 
 -- | Setting the current GHC version failed.
-data GHCupSetError = forall es . Show (V es) => GHCupSetError (V es)
+data GHCupSetError = forall es . (ToVariantMaybe GHCupSetError es, PopVariant GHCupSetError es, Show (V es), Pretty (V es)) => GHCupSetError (V es)
 
 instance Pretty GHCupSetError where
   pPrint (GHCupSetError reason) =
-    text [i|Setting the current GHC version failed: #{reason}|]
+    case reason of
+      VMaybe (_ :: GHCupSetError) -> pPrint reason
+      _ -> text "Setting the current GHC version failed:" <+> pPrint reason
 
 deriving instance Show GHCupSetError
 
@@ -330,7 +341,7 @@ data ParseError = ParseError String
 
 instance Pretty ParseError where
   pPrint (ParseError reason) =
-    text [i|Parsing failed: #{reason}|]
+    text "Parsing failed:" <+> pPrint reason
 
 instance Exception ParseError
 
@@ -340,7 +351,7 @@ data UnexpectedListLength = UnexpectedListLength String
 
 instance Pretty UnexpectedListLength where
   pPrint (UnexpectedListLength reason) =
-    text [i|List length unexpected: #{reason}|]
+    text "List length unexpected:" <+> pPrint reason
 
 instance Exception UnexpectedListLength
 
@@ -349,7 +360,7 @@ data NoUrlBase = NoUrlBase Text
 
 instance Pretty NoUrlBase where
   pPrint (NoUrlBase url) =
-    text [i|Couldn't get a base filename from url #{url}|]
+    text "Couldn't get a base filename from url" <+> pPrint url
 
 instance Exception NoUrlBase
 
@@ -374,23 +385,22 @@ instance
 
 instance Pretty URIParseError where
   pPrint (MalformedScheme reason) =
-    text [i|Failed to parse URI. Malformed scheme: #{reason}|]
+    text "Failed to parse URI. Malformed scheme:" <+> text (show reason)
   pPrint MalformedUserInfo =
-    text [i|Failed to parse URI. Malformed user info.|]
+    text "Failed to parse URI. Malformed user info."
   pPrint MalformedQuery =
-    text [i|Failed to parse URI. Malformed query.|]
+    text "Failed to parse URI. Malformed query."
   pPrint MalformedFragment =
-    text [i|Failed to parse URI. Malformed fragment.|]
+    text "Failed to parse URI. Malformed fragment."
   pPrint MalformedHost =
-    text [i|Failed to parse URI. Malformed host.|]
+    text "Failed to parse URI. Malformed host."
   pPrint MalformedPort =
-    text [i|Failed to parse URI. Malformed port.|]
+    text "Failed to parse URI. Malformed port."
   pPrint MalformedPath =
-    text [i|Failed to parse URI. Malformed path.|]
+    text "Failed to parse URI. Malformed path."
   pPrint (OtherError err) =
-    text [i|Failed to parse URI: #{err}|]
+    text "Failed to parse URI:" <+> pPrint err
 
-#if !defined(TAR)
 instance Pretty ArchiveResult where
   pPrint ArchiveFatal = text "Archive result: fatal"
   pPrint ArchiveFailed = text "Archive result: failed"
@@ -398,14 +408,6 @@ instance Pretty ArchiveResult where
   pPrint ArchiveRetry = text "Archive result: retry"
   pPrint ArchiveOk = text "Archive result: Ok"
   pPrint ArchiveEOF = text "Archive result: EOF"
-#else
+
-instance Pretty Tar.FormatError where
+instance Pretty T.Text where
-  pPrint Tar.TruncatedArchive = text "Truncated archive"
+  pPrint = text . T.unpack
-  pPrint Tar.ShortTrailer = text "Short trailer"
-  pPrint Tar.BadTrailer = text "Bad trailer"
-  pPrint Tar.TrailingJunk = text "Trailing junk"
-  pPrint Tar.ChecksumIncorrect = text "Checksum incorrect"
-  pPrint Tar.NotTarFormat = text "Not a tar format"
-  pPrint Tar.UnrecognisedTarFormat = text "Unrecognised tar format"
-  pPrint Tar.HeaderBadNumericEncoding = text "Header has bad numeric encoding"
-#endif

lib/GHCup/Platform.hs

@@ -20,20 +20,20 @@ module GHCup.Platform where
 
 import           GHCup.Errors
 import           GHCup.Types
+import           GHCup.Types.Optics
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.File
+import           GHCup.Utils.Logger
 import           GHCup.Utils.Prelude
 import           GHCup.Utils.String.QQ
 
 import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
-import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Data.ByteString                ( ByteString )
 import           Data.Foldable
 import           Data.Maybe
-import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           Haskus.Utils.Variant.Excepts
@@ -58,7 +58,7 @@ import qualified Data.Text.IO                  as T
 
 
 -- | Get the full platform request, consisting of architecture, distro, ...
-platformRequest :: (Alternative m, MonadFail m, MonadLogger m, MonadCatch m, MonadIO m)
+platformRequest :: (MonadReader env m, Alternative m, MonadFail m, HasLog env, MonadCatch m, MonadIO m)
                 => Excepts
                      '[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound]
                      m
@@ -83,7 +83,7 @@ getArchitecture = case arch of
   what          -> Left (NoCompatibleArch what)
 
 
-getPlatform :: (Alternative m, MonadLogger m, MonadCatch m, MonadIO m, MonadFail m)
+getPlatform :: (Alternative m, MonadReader env m, HasLog env, MonadCatch m, MonadIO m, MonadFail m)
             => Excepts
                  '[NoCompatiblePlatform, DistroNotFound]
                  m
@@ -108,7 +108,7 @@ getPlatform = do
       pure $ PlatformResult { _platform = FreeBSD, _distroVersion = ver }
     "mingw32" -> pure PlatformResult { _platform = Windows, _distroVersion = Nothing }
     what -> throwE $ NoCompatiblePlatform what
-  lift $ $(logDebug) [i|Identified Platform as: #{prettyShow pfr}|]
+  lift $ logDebug $ "Identified Platform as: " <> T.pack (prettyShow pfr)
   pure pfr
  where
   getFreeBSDVersion = lift $ fmap _stdOut $ executeOut "freebsd-version" [] Nothing
@@ -142,9 +142,7 @@ getLinuxDistro = do
         | otherwise                -> UnknownLinux
   pure (distro, parsedVer)
  where
-  hasWord t matches = foldr (\x y -> match (regex x) (T.unpack t) || y)
+  hasWord t = any (\x -> match (regex x) (T.unpack t))
-                            False
-                            matches
    where
     regex x = makeRegexOpts compIgnoreCase execBlank ([s|\<|] ++ x ++ [s|\>|])
 

lib/GHCup/Requirements.hs

@@ -60,9 +60,10 @@ getCommonRequirements pr tr =
 prettyRequirements :: Requirements -> T.Text
 prettyRequirements Requirements {..} =
   let d = if not . null $ _distroPKGs
-        then
+        then "\n  Please ensure the following distro packages "
-          "\n  Please install the following distro packages: "
+          <> "are installed before continuing (you can exit ghcup "
-            <> T.intercalate " " _distroPKGs
+          <> "and return at any time): "
+          <> T.intercalate " " _distroPKGs
         else ""
       n = if not . T.null $ _notes then "\n  Note: " <> _notes else ""
   in  "System requirements " <> d <> n

lib/GHCup/Types.hs

@@ -25,21 +25,17 @@ module GHCup.Types
   )
   where
 
-import           Control.Applicative
 import           Control.DeepSeq                ( NFData, rnf )
-import           Control.Monad.Logger
 import           Data.Map.Strict                ( Map )
 import           Data.List.NonEmpty             ( NonEmpty (..) )
 import           Data.Text                      ( Text )
 import           Data.Versions
-import           Haskus.Utils.Variant.Excepts
 import           Text.PrettyPrint.HughesPJClass (Pretty, pPrint, text)
 import           URI.ByteString
 #if defined(BRICK)
 import           Graphics.Vty                   ( Key(..) )
 #endif
 
-import qualified Control.Monad.Trans.Class     as Trans
 import qualified Data.Text                     as T
 import qualified GHC.Generics                  as GHC
 
@@ -115,6 +111,13 @@ data Tool = GHC
           | Stack
   deriving (Eq, GHC.Generic, Ord, Show, Enum, Bounded)
 
+instance Pretty Tool where
+  pPrint GHC = text "ghc"
+  pPrint Cabal = text "cabal"
+  pPrint GHCup = text "ghcup"
+  pPrint HLS = text "hls"
+  pPrint Stack = text "stack"
+
 instance NFData Tool
 
 data GlobalTool = ShimGen
@@ -145,7 +148,7 @@ data Tag = Latest
          | Recommended
          | Prerelease
          | Base PVP
-         | Old                -- ^ old version are hidden by default in TUI
+         | Old                -- ^ old versions are hidden by default in TUI
          | UnknownTag String  -- ^ used for upwardscompat
          deriving (Ord, Eq, GHC.Generic, Show) -- FIXME: manual JSON instance
 
@@ -233,7 +236,7 @@ instance NFData LinuxDistro
 distroToString :: LinuxDistro -> String
 distroToString Debian = "debian"
 distroToString Ubuntu = "ubuntu"
-distroToString Mint= "mint"
+distroToString Mint = "mint"
 distroToString Fedora = "fedora"
 distroToString CentOS = "centos"
 distroToString RedHat = "redhat"
@@ -298,11 +301,12 @@ data UserSettings = UserSettings
   , uKeyBindings :: Maybe UserKeyBindings
   , uUrlSource   :: Maybe URLSource
   , uNoNetwork   :: Maybe Bool
+  , uGPGSetting  :: Maybe GPGSetting
   }
   deriving (Show, GHC.Generic)
 
 defaultUserSettings :: UserSettings
-defaultUserSettings = UserSettings Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing
+defaultUserSettings = UserSettings Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing
 
 fromSettings :: Settings -> Maybe KeyBindings -> UserSettings
 fromSettings Settings{..} Nothing =
@@ -315,6 +319,7 @@ fromSettings Settings{..} Nothing =
     , uNoNetwork = Just noNetwork
     , uKeyBindings = Nothing
     , uUrlSource = Just urlSource
+    , uGPGSetting = Just gpgSetting
   }
 fromSettings Settings{..} (Just KeyBindings{..}) =
   let ukb = UserKeyBindings
@@ -337,6 +342,7 @@ fromSettings Settings{..} (Just KeyBindings{..}) =
     , uNoNetwork = Just noNetwork
     , uKeyBindings = Just ukb
     , uUrlSource = Just urlSource
+    , uGPGSetting = Just gpgSetting
   }
 
 data UserKeyBindings = UserKeyBindings
@@ -387,6 +393,7 @@ data AppState = AppState
   , keyBindings :: KeyBindings
   , ghcupInfo :: GHCupInfo
   , pfreq :: PlatformRequest
+  , loggerConfig :: LoggerConfig
   } deriving (Show, GHC.Generic)
 
 instance NFData AppState
@@ -395,6 +402,7 @@ data LeanAppState = LeanAppState
   { settings :: Settings
   , dirs :: Dirs
   , keyBindings :: KeyBindings
+  , loggerConfig :: LoggerConfig
   } deriving (Show, GHC.Generic)
 
 instance NFData LeanAppState
@@ -408,6 +416,7 @@ data Settings = Settings
   , verbose    :: Bool
   , urlSource  :: URLSource
   , noNetwork  :: Bool
+  , gpgSetting :: GPGSetting
   }
   deriving (Show, GHC.Generic)
 
@@ -441,6 +450,13 @@ data Downloader = Curl
 
 instance NFData Downloader
 
+data GPGSetting = GPGStrict
+                | GPGLax
+                | GPGNone
+  deriving (Eq, Show, Ord, GHC.Generic)
+
+instance NFData GPGSetting
+
 data DebugInfo = DebugInfo
   { diBaseDir  :: FilePath
   , diBinDir   :: FilePath
@@ -546,14 +562,26 @@ instance Pretty Versioning where
 instance Pretty Version where
   pPrint = text . T.unpack . prettyVer
 
+instance Show (a -> b) where
+  show _ = "<function>"
 
-instance (Monad m, Alternative m) => Alternative (LoggingT m) where
+instance Show (IO ()) where
-    empty   = Trans.lift empty
+  show _ = "<io>"
-    {-# INLINE empty #-}
-    m <|> n = LoggingT $ \ r -> runLoggingT m r <|> runLoggingT n r
-    {-# INLINE (<|>) #-}
 
 
-instance MonadLogger m => MonadLogger (Excepts e m) where
+data LogLevel = Warn
-  monadLoggerLog a b c d = Trans.lift $ monadLoggerLog a b c d
+              | Info
+              | Debug
+              | Error
+  deriving (Eq, Ord, Show)
 
+data LoggerConfig = LoggerConfig
+  { lcPrintDebug   :: Bool            -- ^ whether to print debug in colorOutter
+  , consoleOutter  :: T.Text -> IO () -- ^ how to write the console output
+  , fileOutter     :: T.Text -> IO () -- ^ how to write the file output
+  , fancyColors    :: Bool
+  }
+  deriving Show
+
+instance NFData LoggerConfig where
+  rnf (LoggerConfig !lcPrintDebug !_ !_ !fancyColors) = rnf (lcPrintDebug, fancyColors)

lib/GHCup/Types/JSON.hs

@@ -24,6 +24,8 @@ module GHCup.Types.JSON where
 import           GHCup.Types
 import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
+import           GHCup.Utils.Logger             () -- TH is broken shite and needs GHCup.Utils.Logger for linking, although we don't depend on the file.
+                                                   -- This is due to the boot file.
 
 import           Control.Applicative            ( (<|>) )
 import           Data.Aeson
@@ -42,7 +44,7 @@ import qualified Text.Megaparsec               as MP
 import qualified Text.Megaparsec.Char          as MPC
 
 
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } { fieldLabelModifier = removeLensFieldLabel } ''Architecture
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Architecture
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''LinuxDistro
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VSep
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VUnit
@@ -54,6 +56,7 @@ deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GlobalTool
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''KeepDirs
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Downloader
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GPGSetting
 
 instance ToJSON Tag where
   toJSON Latest             = String "Latest"

lib/GHCup/Types/Optics.hs

@@ -6,6 +6,7 @@
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE AllowAmbiguousTypes   #-}
 {-# LANGUAGE MultiParamTypeClasses   #-}
+{-# LANGUAGE OverloadedStrings   #-}
 
 {-|
 Module      : GHCup.Types.Optics
@@ -21,10 +22,11 @@ module GHCup.Types.Optics where
 import           GHCup.Types
 
 import           Control.Monad.Reader
-import           Data.ByteString                ( ByteString )
+import           Data.ByteString         ( ByteString )
 import           Optics
 import           URI.ByteString
 
+
 makePrisms ''Tool
 makePrisms ''Architecture
 makePrisms ''LinuxDistro
@@ -87,13 +89,15 @@ getLeanAppState :: ( MonadReader env m
                    , LabelOptic' "settings"    A_Lens env Settings
                    , LabelOptic' "dirs"        A_Lens env Dirs
                    , LabelOptic' "keyBindings" A_Lens env KeyBindings
+                   , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
                    )
                 => m LeanAppState
 getLeanAppState = do
   s <- gets @"settings"
   d <- gets @"dirs"
   k <- gets @"keyBindings"
-  pure (LeanAppState s d k)
+  l <- gets @"loggerConfig"
+  pure (LeanAppState s d k l)
 
 
 getSettings :: ( MonadReader env m
@@ -110,6 +114,13 @@ getDirs :: ( MonadReader env m
 getDirs = gets @"dirs"
 
 
+getLogCleanup :: ( MonadReader env m
+                 , LabelOptic' "logCleanup" A_Lens env (IO ())
+                 )
+              => m (IO ())
+getLogCleanup = gets @"logCleanup"
+
+
 getKeyBindings :: ( MonadReader env m
                   , LabelOptic' "keyBindings" A_Lens env KeyBindings
                   )
@@ -136,6 +147,7 @@ type HasDirs env = (LabelOptic' "dirs" A_Lens env Dirs)
 type HasKeyBindings env = (LabelOptic' "keyBindings" A_Lens env KeyBindings)
 type HasGHCupInfo env = (LabelOptic' "ghcupInfo" A_Lens env GHCupInfo)
 type HasPlatformReq env = (LabelOptic' "pfreq" A_Lens env PlatformRequest)
+type HasLog env = (LabelOptic' "loggerConfig" A_Lens env LoggerConfig)
 
 
 getCache :: (MonadReader env m, HasSettings env) => m Bool

lib/GHCup/Utils.hs

@@ -35,21 +35,18 @@ import           GHCup.Types.Optics
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.Dirs
 import           GHCup.Utils.File
+import           GHCup.Utils.Logger
 import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
 import           GHCup.Utils.String.QQ
 
-#if !defined(TAR)
 import           Codec.Archive           hiding ( Directory )
-#endif
-import           Codec.Archive.Zip
 import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
 #endif
-import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
                                          hiding ( throwM )
@@ -61,10 +58,8 @@ import           Data.ByteString                ( ByteString )
 import           Data.Either
 import           Data.Foldable
 import           Data.List
-import           Data.List.Extra
 import           Data.List.NonEmpty             ( NonEmpty( (:|) ))
 import           Data.Maybe
-import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           GHC.IO.Exception
@@ -83,9 +78,6 @@ import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
 import           Text.Regex.Posix
 import           URI.ByteString
 
-#if defined(TAR)
-import qualified Codec.Archive.Tar             as Tar
-#endif
 import qualified Codec.Compression.BZip        as BZip
 import qualified Codec.Compression.GZip        as GZip
 import qualified Codec.Compression.Lzma        as Lzma
@@ -121,7 +113,7 @@ ghcLinkDestination tool ver = do
 rmMinorSymlinks :: ( MonadReader env m
                    , HasDirs env
                    , MonadIO m
-                   , MonadLogger m
+                   , HasLog env
                    , MonadThrow m
                    , MonadFail m
                    , MonadMask m
@@ -135,14 +127,14 @@ rmMinorSymlinks tv@GHCTargetVersion{..} = do
   forM_ files $ \f -> do
     let f_xyz = f <> "-" <> T.unpack (prettyVer _tvVersion) <> exeExt
     let fullF = binDir </> f_xyz
-    lift $ $(logDebug) [i|rm -f #{fullF}|]
+    lift $ logDebug ("rm -f " <> T.pack fullF)
     lift $ hideError doesNotExistErrorType $ rmLink fullF
 
 
 -- | Removes the set ghc version for the given target, if any.
 rmPlain :: ( MonadReader env m
            , HasDirs env
-           , MonadLogger m
+           , HasLog env
            , MonadThrow m
            , MonadFail m
            , MonadIO m
@@ -157,11 +149,11 @@ rmPlain target = do
     files <- liftE $ ghcToolFiles tv
     forM_ files $ \f -> do
       let fullF = binDir </> f <> exeExt
-      lift $ $(logDebug) [i|rm -f #{fullF}|]
+      lift $ logDebug ("rm -f " <> T.pack fullF)
       lift $ hideError doesNotExistErrorType $ rmLink fullF
     -- old ghcup
     let hdc_file = binDir </> "haddock-ghc" <> exeExt
-    lift $ $(logDebug) [i|rm -f #{hdc_file}|]
+    lift $ logDebug ("rm -f " <> T.pack hdc_file)
     lift $ hideError doesNotExistErrorType $ rmLink hdc_file
 
 
@@ -169,7 +161,7 @@ rmPlain target = do
 rmMajorSymlinks :: ( MonadReader env m
                    , HasDirs env
                    , MonadIO m
-                   , MonadLogger m
+                   , HasLog env
                    , MonadThrow m
                    , MonadFail m
                    , MonadMask m
@@ -185,7 +177,7 @@ rmMajorSymlinks tv@GHCTargetVersion{..} = do
   forM_ files $ \f -> do
     let f_xy = f <> "-" <> T.unpack v' <> exeExt
     let fullF = binDir </> f_xy
-    lift $ $(logDebug) [i|rm -f #{fullF}|]
+    lift $ logDebug ("rm -f " <> T.pack fullF)
     lift $ hideError doesNotExistErrorType $ rmLink fullF
 
 
@@ -257,8 +249,7 @@ getInstalledGHCs = do
 
 
 -- | Get all installed cabals, by matching on @~\/.ghcup\/bin/cabal-*@.
-getInstalledCabals :: ( MonadLogger m
+getInstalledCabals :: ( MonadReader env m
-                      , MonadReader env m
                       , HasDirs env
                       , MonadIO m
                       , MonadCatch m
@@ -277,14 +268,14 @@ getInstalledCabals = do
 
 
 -- | Whether the given cabal version is installed.
-cabalInstalled :: (MonadLogger m, MonadIO m, MonadReader env m, HasDirs env, MonadCatch m) => Version -> m Bool
+cabalInstalled :: (MonadIO m, MonadReader env m, HasDirs env, MonadCatch m) => Version -> m Bool
 cabalInstalled ver = do
   vers <- fmap rights getInstalledCabals
   pure $ elem ver vers
 
 
 -- Return the currently set cabal version, if any.
-cabalSet :: (MonadLogger m, MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
+cabalSet :: (HasLog env, MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
 cabalSet = do
   Dirs {..}  <- getDirs
   let cabalbin = binDir </> "cabal" <> exeExt
@@ -301,7 +292,11 @@ cabalSet = do
         case linkVersion =<< link of
           Right v -> pure $ Just v
           Left err -> do
-            $(logWarn) [i|Failed to parse cabal symlink target with: "#{err}". The symlink #{cabalbin} needs to point to valid cabal binary, such as 'cabal-3.4.0.0'.|]
+            logWarn $ "Failed to parse cabal symlink target with: "
+              <> T.pack (displayException err)
+              <> ". The symlink "
+              <> T.pack cabalbin
+              <> " needs to point to valid cabal binary, such as 'cabal-3.4.0.0'."
             pure Nothing
  where
   -- We try to be extra permissive with link destination parsing,
@@ -368,7 +363,7 @@ getInstalledStacks = do
 
 -- Return the currently set stack version, if any.
 -- TODO: there's a lot of code duplication here :>
-stackSet :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m, MonadLogger m) => m (Maybe Version)
+stackSet :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m, HasLog env) => m (Maybe Version)
 stackSet = do
   Dirs {..}  <- getDirs
   let stackBin = binDir </> "stack" <> exeExt
@@ -385,7 +380,11 @@ stackSet = do
         case linkVersion =<< link of
           Right v -> pure $ Just v
           Left err -> do
-            $(logWarn) [i|Failed to parse stack symlink target with: "#{err}". The symlink #{stackBin} needs to point to valid stack binary, such as 'stack-2.7.1'.|]
+            logWarn $ "Failed to parse stack symlink target with: "
+              <> T.pack (displayException err)
+              <> ". The symlink "
+              <> T.pack stackBin
+              <> " needs to point to valid stack binary, such as 'stack-2.7.1'."
             pure Nothing
  where
   linkVersion :: MonadThrow m => FilePath -> m Version
@@ -476,7 +475,7 @@ hlsGHCVersions = do
         . splitOn "~"
         )
       bins
-  pure . rights . concat . maybeToList $ vers
+  pure . sortBy (flip compare) . rights . concat . maybeToList $ vers
 
 
 -- | Get all server binaries for an hls version, if any.
@@ -599,31 +598,21 @@ getLatestGHCFor major' minor' dls =
 
 
 -- | Unpack an archive to a temporary directory and return that path.
-unpackToDir :: (MonadLogger m, MonadIO m, MonadThrow m)
+unpackToDir :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m)
             => FilePath       -- ^ destination dir
             -> FilePath       -- ^ archive path
             -> Excepts '[UnknownArchive
-#if !defined(TAR)
                         , ArchiveResult
-#endif
                         ] m ()
 unpackToDir dfp av = do
   let fn = takeFileName av
-  lift $ $(logInfo) [i|Unpacking: #{fn} to #{dfp}|]
+  lift $ logInfo $ "Unpacking: " <> T.pack fn <> " to " <> T.pack dfp
 
-#if defined(TAR)
-  let untar :: MonadIO m => BL.ByteString -> Excepts '[] m ()
-      untar = liftIO . Tar.unpack dfp . Tar.read
-
-      rf :: MonadIO m => FilePath -> Excepts '[] m BL.ByteString
-      rf = liftIO . BL.readFile
-#else
   let untar :: MonadIO m => BL.ByteString -> Excepts '[ArchiveResult] m ()
       untar = lEM . liftIO . runArchiveM . unpackToDirLazy dfp
 
       rf :: MonadIO m => FilePath -> Excepts '[ArchiveResult] m BL.ByteString
       rf = liftIO . BL.readFile
-#endif
 
   -- extract, depending on file extension
   if
@@ -636,42 +625,23 @@ unpackToDir dfp av = do
     | ".tar.bz2" `isSuffixOf` fn ->
       liftE (untar . BZip.decompress =<< rf av)
     | ".tar" `isSuffixOf` fn -> liftE (untar =<< rf av)
-    | ".zip" `isSuffixOf` fn ->
+    | ".zip" `isSuffixOf` fn -> liftE (untar =<< rf av)
-      withArchive av (unpackInto dfp)
     | otherwise -> throwE $ UnknownArchive fn
 
 
-getArchiveFiles :: (MonadLogger m, MonadIO m, MonadThrow m)
+getArchiveFiles :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m)
                 => FilePath       -- ^ archive path
                 -> Excepts '[UnknownArchive
-#if defined(TAR)
-                            , Tar.FormatError
-#else
                             , ArchiveResult
-#endif
                             ] m [FilePath]
 getArchiveFiles av = do
   let fn = takeFileName av
 
-#if defined(TAR)
-  let entries :: Monad m => BL.ByteString -> Excepts '[Tar.FormatError] m [FilePath]
-      entries =
-          lE @Tar.FormatError
-          . Tar.foldEntries
-            (\e x -> fmap (Tar.entryPath e :) x)
-            (Right [])
-            (\e -> Left e)
-          . Tar.read
-
-      rf :: MonadIO m => FilePath -> Excepts '[Tar.FormatError] m BL.ByteString
-      rf = liftIO . BL.readFile
-#else
   let entries :: Monad m => BL.ByteString -> Excepts '[ArchiveResult] m [FilePath]
       entries = (fmap . fmap) filepath . lE . readArchiveBSL
 
       rf :: MonadIO m => FilePath -> Excepts '[ArchiveResult] m BL.ByteString
       rf = liftIO . BL.readFile
-#endif
 
   -- extract, depending on file extension
   if
@@ -684,14 +654,11 @@ getArchiveFiles av = do
     | ".tar.bz2" `isSuffixOf` fn ->
       liftE (entries . BZip.decompress =<< rf av)
     | ".tar" `isSuffixOf` fn -> liftE (entries =<< rf av)
-    | ".zip" `isSuffixOf` fn ->
+    | ".zip" `isSuffixOf` fn -> liftE (entries =<< rf av)
-      withArchive av $ do
-        entries' <- getEntries
-        pure $ fmap unEntrySelector $ Map.keys entries'
     | otherwise -> throwE $ UnknownArchive fn
 
 
-intoSubdir :: (MonadLogger m, MonadIO m, MonadThrow m, MonadCatch m)
+intoSubdir :: (MonadReader env m, HasLog env, MonadIO m, MonadThrow m, MonadCatch m)
            => FilePath       -- ^ unpacked tar dir
            -> TarDir         -- ^ how to descend
            -> Excepts '[TarDirDoesNotExist] m FilePath
@@ -819,14 +786,19 @@ makeOut args workdir = do
 
 -- | Try to apply patches in order. Fails with 'PatchFailed'
 -- on first failure.
-applyPatches :: (MonadReader env m, HasDirs env, MonadLogger m, MonadIO m)
+applyPatches :: (MonadReader env m, HasDirs env, HasLog env, MonadIO m)
              => FilePath   -- ^ dir containing patches
              -> FilePath   -- ^ dir to apply patches in
              -> Excepts '[PatchFailed] m ()
 applyPatches pdir ddir = do
-  patches <- (fmap . fmap) (pdir </>) $ liftIO $ listDirectory pdir
+  patches <- (fmap . fmap) (pdir </>) $ liftIO $ findFiles
+      pdir
+      (makeRegexOpts compExtended
+                     execBlank
+                     ([s|.+\.(patch|diff)$|] :: ByteString)
+      )
   forM_ (sort patches) $ \patch' -> do
-    lift $ $(logInfo) [i|Applying patch #{patch'}|]
+    lift $ logInfo $ "Applying patch " <> T.pack patch'
     fmap (either (const Nothing) Just)
          (exec
            "patch"
@@ -862,13 +834,17 @@ getChangeLog dls tool (Right tag) =
 --   2. the install destination, depending on whether the build failed
 runBuildAction :: ( Pretty (V e)
                   , Show (V e)
+                  , PopVariant BuildFailed e
+                  , ToVariantMaybe BuildFailed e
                   , MonadReader env m
                   , HasDirs env
                   , HasSettings env
                   , MonadIO m
                   , MonadMask m
-                  , MonadLogger m
+                  , HasLog env
                   , MonadUnliftIO m
+                  , MonadFail m
+                  , MonadCatch m
                   )
                => FilePath        -- ^ build directory (cleaned up depending on Settings)
                -> Maybe FilePath  -- ^ dir to *always* clean up on exception
@@ -895,10 +871,10 @@ runBuildAction bdir instdir action = do
 
 -- | Remove a build directory, ignoring if it doesn't exist and gracefully
 -- printing other errors without crashing.
-rmBDir :: (MonadLogger m, MonadUnliftIO m, MonadIO m) => FilePath -> m ()
+rmBDir :: (MonadReader env m, HasLog env, MonadUnliftIO m, MonadIO m) => FilePath -> m ()
 rmBDir dir = withRunInIO (\run -> run $
-           liftIO $ handleIO (\e -> run $ $(logWarn)
+           liftIO $ handleIO (\e -> run $ logWarn $
-               [i|Couldn't remove build dir #{dir}, error was: #{displayException e}|])
+               "Couldn't remove build dir " <> T.pack dir <> ", error was: " <> T.pack (displayException e))
            $ hideError doesNotExistErrorType
            $ rmPathForcibly dir)
 
@@ -1010,7 +986,7 @@ rmLink = hideError doesNotExistErrorType . recycleFile
 -- On windows, this requires that 'ensureGlobalTools' was run beforehand.
 createLink :: ( MonadMask m
               , MonadThrow m
-              , MonadLogger m
+              , HasLog env
               , MonadIO m
               , MonadReader env m
               , HasDirs env
@@ -1032,24 +1008,24 @@ createLink link exe = do
       fullLink = takeDirectory exe </> link
       shimContents = "path = " <> fullLink
 
-  $(logDebug) [i|rm -f #{exe}|]
+  logDebug $ "rm -f " <> T.pack exe
   rmLink exe
 
-  $(logDebug) [i|ln -s #{fullLink} #{exe}|]
+  logDebug $ "ln -s " <> T.pack fullLink <> " " <> T.pack exe
   liftIO $ copyFile shimGen exe
   liftIO $ writeFile shim shimContents
 #else
-  $(logDebug) [i|rm -f #{exe}|]
+  logDebug $ "rm -f " <> T.pack exe
   hideError doesNotExistErrorType $ recycleFile exe
 
-  $(logDebug) [i|ln -s #{link} #{exe}|]
+  logDebug $ "ln -s " <> T.pack link <> " " <> T.pack exe
   liftIO $ createFileLink link exe
 #endif
 
 
 ensureGlobalTools :: ( MonadMask m
                      , MonadThrow m
-                     , MonadLogger m
+                     , HasLog env
                      , MonadIO m
                      , MonadReader env m
                      , HasDirs env
@@ -1058,7 +1034,7 @@ ensureGlobalTools :: ( MonadMask m
                      , MonadUnliftIO m
                      , MonadFail m
                      )
-                  => Excepts '[DigestError , DownloadFailed, NoDownload] m ()
+                  => Excepts '[GPGError, DigestError , DownloadFailed, NoDownload] m ()
 ensureGlobalTools = do
 #if defined(IS_WINDOWS)
   (GHCupInfo _ _ gTools) <- lift getGHCupInfo
@@ -1066,12 +1042,12 @@ ensureGlobalTools = do
   shimDownload <- liftE $ lE @_ @'[NoDownload]
     $ maybe (Left NoDownload) Right $ Map.lookup ShimGen gTools
   let dl = downloadCached' shimDownload (Just "gs.exe") Nothing
-  void $ (\(DigestError _ _) -> do
+  void $ (\(DigestError _ _ _) -> do
-      lift $ $(logWarn) [i|Digest doesn't match, redownloading gs.exe...|]
+      lift $ logWarn "Digest doesn't match, redownloading gs.exe..."
-      lift $ $(logDebug) [i|rm -f #{shimDownload}|]
+      lift $ logDebug ("rm -f " <> T.pack (cacheDir dirs </> "gs.exe"))
       lift $ hideError doesNotExistErrorType $ recycleFile (cacheDir dirs </> "gs.exe")
-      liftE @'[DigestError , DownloadFailed] $ dl
+      liftE @'[GPGError, DigestError , DownloadFailed] $ dl
-    ) `catchE` (liftE @'[DigestError , DownloadFailed] dl)
+    ) `catchE` (liftE @'[GPGError, DigestError , DownloadFailed] dl)
   pure ()
 #else
   pure ()

lib/GHCup/Utils/Dirs.hs

@@ -2,9 +2,7 @@
 {-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE ViewPatterns          #-}
-{-# LANGUAGE TemplateHaskell       #-}
 
 {-|
 Module      : GHCup.Utils.Dirs
@@ -40,17 +38,16 @@ import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Types.Optics
 import           GHCup.Utils.MegaParsec
+import           GHCup.Utils.Logger
 import           GHCup.Utils.Prelude
 
 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Unlift
-import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource hiding (throwM)
 import           Data.Bifunctor
 import           Data.Maybe
-import           Data.String.Interpolate
 import           GHC.IO.Exception               ( IOErrorType(NoSuchThing) )
 import           Haskus.Utils.Variant.Excepts
 import           Optics
@@ -62,7 +59,7 @@ import           System.IO.Temp
 
 import qualified Data.ByteString               as BS
 import qualified Data.Text                     as T
-import qualified Data.Yaml                     as Y
+import qualified Data.YAML.Aeson               as Y
 import qualified Text.Megaparsec               as MP
 import Control.Concurrent (threadDelay)
 
@@ -225,7 +222,7 @@ ghcupConfigFile = do
   contents <- liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ Just <$> BS.readFile filepath
   case contents of
       Nothing -> pure defaultUserSettings
-      Just contents' -> lE' JSONDecodeError . first show . Y.decodeEither' $ contents'
+      Just contents' -> lE' JSONDecodeError . first snd . Y.decode1Strict $ contents'
 
 
     -------------------------
@@ -262,7 +259,7 @@ parseGHCupGHCDir (T.pack -> fp) =
 mkGhcupTmpDir :: ( MonadReader env m
                  , HasDirs env
                  , MonadUnliftIO m
-                 , MonadLogger m
+                 , HasLog env
                  , MonadCatch m
                  , MonadThrow m
                  , MonadMask m
@@ -274,15 +271,21 @@ mkGhcupTmpDir = do
   let minSpace = 5000 -- a rough guess, aight?
   space <- handleIO (\_ -> pure Nothing) $ fmap Just $ liftIO $ getAvailSpace tmpdir
   when (maybe False (toBytes minSpace >) space) $ do
-    $(logWarn) [i|Possibly insufficient disk space on #{tmpdir}. At least #{minSpace} MB are recommended, but only #{toMB (fromJust space)} are free. Consider freeing up disk space or setting TMPDIR env variable.|]
+    logWarn ("Possibly insufficient disk space on "
-    $(logWarn)
+      <> T.pack tmpdir
+      <> ". At least "
+      <> T.pack (show minSpace)
+      <> " MB are recommended, but only "
+      <> toMB (fromJust space)
+      <> " are free. Consider freeing up disk space or setting TMPDIR env variable.")
+    logWarn
       "...waiting for 10 seconds before continuing anyway, you can still abort..."
     liftIO $ threadDelay 10000000 -- give the user a sec to intervene
 
   liftIO $ createTempDirectory tmpdir "ghcup"
  where
   toBytes mb = mb * 1024 * 1024
-  toMB b = show (truncate' (fromIntegral b / (1024 * 1024) :: Double) 2)
+  toMB b = T.pack $ show (truncate' (fromIntegral b / (1024 * 1024) :: Double) 2)
   truncate' :: Double -> Int -> Double
   truncate' x n = fromIntegral (floor (x * t) :: Integer) / t
       where t = 10^n
@@ -290,8 +293,9 @@ mkGhcupTmpDir = do
 
 withGHCupTmpDir :: ( MonadReader env m
                    , HasDirs env
+                   , HasLog env
+                   , HasSettings env
                    , MonadUnliftIO m
-                   , MonadLogger m
                    , MonadCatch m
                    , MonadResource m
                    , MonadThrow m
@@ -304,7 +308,7 @@ withGHCupTmpDir = snd <$> withRunInIO (\run ->
         (run mkGhcupTmpDir)
         (\fp ->
             handleIO (\e -> run
-                $ $(logDebug) [i|Resource cleanup failed for "#{fp}", error was: #{displayException e}|])
+                $ logDebug ("Resource cleanup failed for " <> T.pack fp <> ", error was: " <> T.pack (displayException e)))
             . rmPathForcibly
             $ fp))
 
@@ -336,9 +340,10 @@ relativeSymlink p1 p2 =
 
 cleanupTrash :: ( MonadIO m
                 , MonadMask m
-                , MonadLogger m
                 , MonadReader env m
+                , HasLog env
                 , HasDirs env
+                , HasSettings env
                 )
              => m ()
 cleanupTrash = do
@@ -347,8 +352,8 @@ cleanupTrash = do
   if null contents
   then pure ()
   else do
-    $(logWarn) [i|Removing leftover files in #{recycleDir}|]
+    logWarn ("Removing leftover files in " <> T.pack recycleDir)
     forM_ contents (\fp -> handleIO (\e ->
-        $(logDebug) [i|Resource cleanup failed for "#{fp}", error was: #{displayException e}|]
+        logDebug ("Resource cleanup failed for " <> T.pack fp <> ", error was: " <> T.pack (displayException e))
       ) $ liftIO $ removePathForcibly (recycleDir </> fp))
 

lib/GHCup/Utils/File/Common.hs

@@ -1,4 +1,3 @@
-{-# LANGUAGE QuasiQuotes       #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE FlexibleContexts  #-}
 {-# LANGUAGE TemplateHaskell   #-}
@@ -8,10 +7,10 @@ module GHCup.Utils.File.Common where
 
 import           GHCup.Utils.Prelude
 
-import           Control.Monad.Extra
 import           Control.Monad.Reader
 import           Data.Maybe
-import           Data.String.Interpolate
+import           Data.Text               ( Text )
+import           Data.Void
 import           GHC.IO.Exception
 import           Optics                  hiding ((<|), (|>))
 import           System.Directory
@@ -19,7 +18,9 @@ import           System.FilePath
 import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
 import           Text.Regex.Posix
 
+import qualified Data.Text                     as T
 import qualified Data.ByteString.Lazy          as BL
+import qualified Text.Megaparsec               as MP
 
 
 
@@ -31,13 +32,13 @@ data ProcessError = NonZeroExit Int FilePath [String]
 
 instance Pretty ProcessError where
   pPrint (NonZeroExit e exe args) =
-    text [i|Process "#{exe}" with arguments #{args} failed with exit code #{e}.|]
+    text "Process" <+> pPrint exe <+> text "with arguments" <+> pPrint args <+> text "failed with exit code" <+> text (show e <> ".")
   pPrint (PTerminated exe args) =
-    text [i|Process "#{exe}" with arguments #{args} terminated.|]
+    text "Process" <+> pPrint exe <+> text "with arguments" <+> pPrint args <+> text "terminated."
   pPrint (PStopped exe args) =
-    text [i|Process "#{exe}" with arguments #{args} stopped.|]
+    text "Process" <+> pPrint exe <+> text "with arguments" <+> pPrint args <+> text "stopped."
   pPrint (NoSuchPid exe args) =
-    text [i|Could not find PID for process running "#{exe}" with arguments #{args}.|]
+    text "Could not find PID for process running " <+> pPrint exe <+> text " with arguments " <+> text (show args) <+> text "."
 
 data CapturedProcess = CapturedProcess
   { _exitCode :: ExitCode
@@ -104,3 +105,11 @@ findFiles path regex = do
   contents <- listDirectory path
   pure $ filter (match regex) contents
 
+findFiles' :: FilePath -> MP.Parsec Void Text a -> IO [FilePath]
+findFiles' path parser = do
+  contents <- listDirectory path
+  pure $ filter (\fp -> either (const False) (const True) $ MP.parse parser "" (T.pack fp)) contents
+
+
+checkFileAlreadyExists :: (MonadIO m) => FilePath -> m Bool
+checkFileAlreadyExists fp = liftIO $ doesFileExist fp

lib/GHCup/Utils/File/Common.hs-boot

@@ -0,0 +1,5 @@
+module GHCup.Utils.File.Common where
+
+import           Text.Regex.Posix
+
+findFiles :: FilePath -> Regex -> IO [FilePath]

lib/GHCup/Utils/File/Posix.hs

@@ -1,8 +1,5 @@
-{-# LANGUAGE QuasiQuotes       #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE FlexibleContexts  #-}
-{-# LANGUAGE TemplateHaskell   #-}
-{-# LANGUAGE ViewPatterns      #-}
 
 {-|
 Module      : GHCup.Utils.File.Posix
@@ -20,6 +17,7 @@ module GHCup.Utils.File.Posix where
 
 import           GHCup.Utils.File.Common
 import           GHCup.Utils.Prelude
+import           GHCup.Utils.Logger
 import           GHCup.Types
 import           GHCup.Types.Optics
 
@@ -28,14 +26,12 @@ import           Control.Concurrent.Async
 import           Control.Exception              ( evaluate )
 import           Control.Exception.Safe
 import           Control.Monad
-import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.State.Strict
 import           Data.ByteString                ( ByteString )
 import           Data.Foldable
 import           Data.IORef
 import           Data.Sequence                  ( Seq, (|>) )
-import           Data.String.Interpolate
 import           Data.List
 import           Data.Word8
 import           GHC.IO.Exception
@@ -132,7 +128,7 @@ execLogged exe args chdir lfile env = do
       pure e
 
   tee :: Fd -> Fd -> IO ()
-  tee fileFd fdIn = readTilEOF lineAction fdIn
+  tee fileFd = readTilEOF lineAction
 
    where
     lineAction :: ByteString -> IO ()
@@ -351,7 +347,7 @@ toProcessError exe args mps = case mps of
 
 
 
-chmod_755 :: (MonadLogger m, MonadIO m) => FilePath -> m ()
+chmod_755 :: (MonadReader env m, HasLog env, MonadIO m) => FilePath -> m ()
 chmod_755 fp = do
   let exe_mode =
           nullFileMode
@@ -362,7 +358,7 @@ chmod_755 fp = do
             `unionFileModes` groupReadMode
             `unionFileModes` otherExecuteMode
             `unionFileModes` otherReadMode
-  $(logDebug) [i|chmod 755 #{fp}|]
+  logDebug ("chmod 755 " <> T.pack fp)
   liftIO $ setFileMode fp exe_mode
 
 

lib/GHCup/Utils/Logger.hs

@@ -1,5 +1,7 @@
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE QuasiQuotes      #-}
+{-# LANGUAGE DataKinds        #-}
+{-# LANGUAGE OverloadedStrings   #-}
 
 {-|
 Module      : GHCup.Utils.Logger
@@ -16,15 +18,15 @@ module GHCup.Utils.Logger where
 
 import           GHCup.Types
 import           GHCup.Types.Optics
-import           GHCup.Utils.File
+import {-# SOURCE #-} GHCup.Utils.File.Common
 import           GHCup.Utils.String.QQ
 
 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Class
-import           Control.Monad.Logger
 import           Control.Monad.Reader
-import           Data.Char               ( ord )
+import           Data.Text               ( Text )
+import           Optics
 import           Prelude                 hiding ( appendFile )
 import           System.Console.Pretty
 import           System.FilePath
@@ -33,54 +35,80 @@ import           Text.Regex.Posix
 
 import qualified Data.ByteString               as B
 import GHCup.Utils.Prelude
+import qualified Data.Text                     as T
+
+logInfo :: ( MonadReader env m
+           , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
+           , MonadIO m
+           )
+        => Text
+        -> m ()
+logInfo = logInternal Info
+
+logWarn :: ( MonadReader env m
+           , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
+           , MonadIO m
+           )
+        => Text
+        -> m ()
+logWarn = logInternal Warn
+
+logDebug :: ( MonadReader env m
+            , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
+            , MonadIO m
+            )
+         => Text
+         -> m ()
+logDebug = logInternal Debug
+
+logError :: ( MonadReader env m
+            , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
+            , MonadIO m
+            )
+         => Text
+         -> m ()
+logError = logInternal Error
 
 
-data LoggerConfig = LoggerConfig
+logInternal :: ( MonadReader env m
-  { lcPrintDebug :: Bool                  -- ^ whether to print debug in colorOutter
+               , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
-  , colorOutter  :: B.ByteString -> IO () -- ^ how to write the color output
+               , MonadIO m
-  , rawOutter    :: B.ByteString -> IO () -- ^ how to write the full raw output
+               ) => LogLevel
-  }
+                 -> Text
+                 -> m ()
+logInternal logLevel msg = do
+  LoggerConfig {..} <- gets @"loggerConfig"
+  let color' c = if fancyColors then color c else id
+  let style' = case logLevel of
+        Debug   -> style Bold . color' Blue
+        Info    -> style Bold . color' Green
+        Warn    -> style Bold . color' Yellow
+        Error   -> style Bold . color' Red
+  let l = case logLevel of
+        Debug   -> style' "[ Debug ]"
+        Info    -> style' "[ Info  ]"
+        Warn    -> style' "[ Warn  ]"
+        Error   -> style' "[ Error ]"
+  let strs = T.split (== '\n') msg
+  let out = case strs of
+              [] -> T.empty
+              (x:xs) -> 
+                  foldr (\a b -> a <> "\n" <> b) mempty
+                . ((l <> " " <> x) :)
+                . fmap (\line' -> style' "[ ...   ] " <> line' )
+                $ xs
 
+  when (lcPrintDebug || (not lcPrintDebug && (logLevel /= Debug)))
+    $ liftIO $ consoleOutter out
 
-myLoggerT :: LoggerConfig -> LoggingT m a -> m a
+  -- raw output
-myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
+  let lr = case logLevel of
- where
+        Debug   -> "Debug:"
-  mylogger :: Loc -> LogSource -> LogLevel -> LogStr -> IO ()
+        Info    -> "Info:"
-  mylogger _ _ level str' = do
+        Warn    -> "Warn:"
-    -- color output
+        Error   -> "Error:"
-    let style' = case level of
+  let outr = lr <> " " <> msg <> "\n"
-          LevelDebug   -> style Bold . color Blue
+  liftIO $ fileOutter outr
-          LevelInfo    -> style Bold . color Green
-          LevelWarn    -> style Bold . color Yellow
-          LevelError   -> style Bold . color Red
-          LevelOther _ -> id
-    let l = case level of
-          LevelDebug   -> toLogStr (style' "[ Debug ]")
-          LevelInfo    -> toLogStr (style' "[ Info  ]")
-          LevelWarn    -> toLogStr (style' "[ Warn  ]")
-          LevelError   -> toLogStr (style' "[ Error ]")
-          LevelOther t -> toLogStr "[ " <> toLogStr t <> toLogStr " ]"
-    let strs = fmap toLogStr . B.split (fromIntegral $ ord '\n') . fromLogStr $ str'
-    let out = case strs of
-                [] -> B.empty
-                (x:xs) -> fromLogStr
-                  . foldr (\a b -> a <> toLogStr "\n" <> b) mempty
-                  . ((l <> toLogStr " " <> x) :)
-                  . fmap (\line' -> toLogStr (style' "[ ...   ] ") <> line' )
-                  $ xs
-
-    when (lcPrintDebug || (not lcPrintDebug && (level /= LevelDebug)))
-      $ colorOutter out
-
-    -- raw output
-    let lr = case level of
-          LevelDebug   -> toLogStr "Debug:"
-          LevelInfo    -> toLogStr "Info:"
-          LevelWarn    -> toLogStr "Warn:"
-          LevelError   -> toLogStr "Error:"
-          LevelOther t -> toLogStr t <> toLogStr ":"
-    let outr = fromLogStr (lr <> toLogStr " " <> str' <> toLogStr "\n")
-    rawOutter outr
 
 
 initGHCupFileLogging :: ( MonadReader env m

lib/GHCup/Utils/Logger.hs-boot

@@ -0,0 +1,21 @@
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE QuasiQuotes      #-}
+{-# LANGUAGE DataKinds        #-}
+{-# LANGUAGE OverloadedStrings   #-}
+
+module GHCup.Utils.Logger where
+
+import           GHCup.Types
+
+import           Control.Monad.IO.Class
+import           Control.Monad.Reader
+import           Data.Text               ( Text )
+import           Optics
+
+logWarn :: ( MonadReader env m
+           , LabelOptic' "loggerConfig" A_Lens env LoggerConfig
+           , MonadIO m
+           )
+        => Text
+        -> m ()
+

lib/GHCup/Utils/Prelude.hs

@@ -5,7 +5,6 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeFamilies        #-}
 {-# LANGUAGE TypeOperators       #-}
-{-# LANGUAGE TemplateHaskell     #-}
 
 {-|
 Module      : GHCup.Utils.Prelude
@@ -24,16 +23,17 @@ module GHCup.Utils.Prelude where
 import           GHCup.Types
 #endif
 import           GHCup.Types.Optics
+import {-# SOURCE #-} GHCup.Utils.Logger
 
 import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Class
 import           Control.Monad.Reader
-import           Control.Monad.Logger
 import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
-import           Data.List                      ( nub, intercalate )
+import           Data.List                      ( nub, intercalate, stripPrefix, isPrefixOf )
+import           Data.Maybe
 import           Data.Foldable
 import           Data.String
 import           Data.Text                      ( Text )
@@ -75,8 +75,9 @@ import qualified System.Win32.File             as Win32
 -- >>> import Data.ByteString.Internal (c2w, w2c)
 -- >>> import Test.QuickCheck
 -- >>> import Data.Word8
--- >>> import Data.Word8
 -- >>> import qualified Data.Text as T
+-- >>> import qualified Data.Char as C
+-- >>> import Data.List
 -- >>> instance Arbitrary T.Text where arbitrary = T.pack <$> arbitrary
 
 
@@ -174,8 +175,12 @@ lEM' :: forall e' e es a m
 lEM' f em = lift em >>= lE . first f
 
 -- for some obscure reason... this won't type-check if we move it to a different module
-catchWarn :: forall es m . (Pretty (V es), MonadLogger m, Monad m) => Excepts es m () -> Excepts '[] m ()
+catchWarn :: forall es m env . ( Pretty (V es)
-catchWarn = catchAllE @_ @es (\v -> lift $ $(logWarn) (T.pack . prettyShow $ v))
+                             , MonadReader env m
+                             , HasLog env
+                             , MonadIO m
+                             , Monad m) => Excepts es m () -> Excepts '[] m ()
+catchWarn = catchAllE @_ @es (\v -> lift $ logWarn (T.pack . prettyShow $ v))
 
 fromEither :: Either a b -> VEither '[a] b
 fromEither = either (VLeft . V) VRight
@@ -520,7 +525,7 @@ forFold :: (Foldable t, Applicative m, Monoid b) => t a -> (a -> m b) -> m b
 forFold = \t -> (`traverseFold` t)
 
 
--- | Strip @\\r@ and @\\n@ from 'ByteString's
+-- | Strip @\\r@ and @\\n@ from 'String's
 --
 -- >>> stripNewline "foo\n\n\n"
 -- "foo"
@@ -532,13 +537,10 @@ forFold = \t -> (`traverseFold` t)
 -- prop> \t -> stripNewline (t <> "\n") === stripNewline t
 -- prop> \t -> not (any (isNewLine . c2w) t) ==> stripNewline t == t
 stripNewline :: String -> String
-stripNewline s
+stripNewline = filter (`notElem` "\n\r")
-  | null s               = []
-  | head s `elem` "\n\r" = stripNewline (tail s)
-  | otherwise            = head s : stripNewline (tail s)
 
 
--- | Strip @\\r@ and @\\n@ from 'ByteString's
+-- | Strip @\\r@ and @\\n@ from 'Text's
 --
 -- >>> stripNewline' "foo\n\n\n"
 -- "foo"
@@ -550,10 +552,7 @@ stripNewline s
 -- prop> \t -> stripNewline' (t <> "\n") === stripNewline' t
 -- prop> \t -> not (T.any (isNewLine . c2w) t) ==> stripNewline' t == t
 stripNewline' :: T.Text -> T.Text
-stripNewline' s
+stripNewline' = T.filter (`notElem` "\n\r")
-  | T.null s               = mempty
-  | T.head s `elem` "\n\r" = stripNewline' (T.tail s)
-  | otherwise              = T.singleton (T.head s) <> stripNewline' (T.tail s)
 
 
 -- | Is the word8 a newline?
@@ -587,3 +586,117 @@ splitOnPVP c s = case Split.splitOn c s of
     | otherwise -> def
  where
   def = (s, "")
+
+
+
+-- | Like 'find', but where the test can be monadic.
+--
+-- >>> findM (Just . C.isUpper) "teST"
+-- Just (Just 'S')
+-- >>> findM (Just . C.isUpper) "test"
+-- Just Nothing
+-- >>> findM (Just . const True) ["x",undefined]
+-- Just (Just "x")
+findM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a)
+findM ~p = foldr (\x -> ifM (p x) (pure $ Just x)) (pure Nothing)
+
+
+-- | Drops the given suffix from a list.
+--   It returns the original sequence if the sequence doesn't end with the given suffix.
+--
+-- >>> dropSuffix "!" "Hello World!"
+-- "Hello World"
+-- >>> dropSuffix "!" "Hello World!!"
+-- "Hello World!"
+-- >>> dropSuffix "!" "Hello World."
+-- "Hello World."
+dropSuffix :: Eq a => [a] -> [a] -> [a]
+dropSuffix a b = fromMaybe b $ stripSuffix a b
+
+-- | Return the prefix of the second list if its suffix
+--   matches the entire first list.
+--
+-- >>> stripSuffix "bar" "foobar"
+-- Just "foo"
+-- >>> stripSuffix ""    "baz"
+-- Just "baz"
+-- >>> stripSuffix "foo" "quux"
+-- Nothing
+stripSuffix :: Eq a => [a] -> [a] -> Maybe [a]
+stripSuffix a b = reverse <$> stripPrefix (reverse a) (reverse b)
+
+
+-- | Drops the given prefix from a list.
+--   It returns the original sequence if the sequence doesn't start with the given prefix.
+--
+-- >>> dropPrefix "Mr. " "Mr. Men"
+-- "Men"
+-- >>> dropPrefix "Mr. " "Dr. Men"
+-- "Dr. Men"
+dropPrefix :: Eq a => [a] -> [a] -> [a]
+dropPrefix a b = fromMaybe b $ stripPrefix a b
+
+
+
+-- | Break a list into pieces separated by the first
+-- list argument, consuming the delimiter. An empty delimiter is
+-- invalid, and will cause an error to be raised.
+--
+-- >>> splitOn "\r\n" "a\r\nb\r\nd\r\ne"
+-- ["a","b","d","e"]
+-- >>> splitOn "aaa"  "aaaXaaaXaaaXaaa"
+-- ["","X","X","X",""]
+-- >>> splitOn "x"    "x"
+-- ["",""]
+-- >>> splitOn "x"    ""
+-- [""]
+--
+-- prop> \s x -> s /= "" ==> intercalate s (splitOn s x) == x
+-- prop> \c x -> splitOn [c] x                           == split (==c) x
+splitOn :: Eq a => [a] -> [a] -> [[a]]
+splitOn [] _ = error "splitOn, needle may not be empty"
+splitOn _ [] = [[]]
+splitOn needle haystack = a : if null b then [] else splitOn needle $ drop (length needle) b
+    where (a,b) = breakOn needle haystack
+
+
+-- | Splits a list into components delimited by separators,
+-- where the predicate returns True for a separator element.  The
+-- resulting components do not contain the separators.  Two adjacent
+-- separators result in an empty component in the output.
+--
+-- >>> split (== 'a') "aabbaca"
+-- ["","","bb","c",""]
+-- >>> split (== 'a') ""
+-- [""]
+-- >>> split (== ':') "::xyz:abc::123::"
+-- ["","","xyz","abc","","123","",""]
+-- >>> split (== ',') "my,list,here"
+-- ["my","list","here"]
+split :: (a -> Bool) -> [a] -> [[a]]
+split _ [] = [[]]
+split f (x:xs)
+  | f x = [] : split f xs
+  | y:ys <- split f xs = (x:y) : ys
+  | otherwise = [[]]
+
+
+-- | Find the first instance of @needle@ in @haystack@.
+-- The first element of the returned tuple
+-- is the prefix of @haystack@ before @needle@ is matched.  The second
+-- is the remainder of @haystack@, starting with the match.
+-- If you want the remainder /without/ the match, use 'stripInfix'.
+--
+-- >>> breakOn "::" "a::b::c"
+-- ("a","::b::c")
+-- >>> breakOn "/" "foobar"
+-- ("foobar","")
+--
+-- prop> \needle haystack -> let (prefix,match) = breakOn needle haystack in prefix ++ match == haystack
+breakOn :: Eq a => [a] -> [a] -> ([a], [a])
+breakOn needle haystack | needle `isPrefixOf` haystack = ([], haystack)
+breakOn _ [] = ([], [])
+breakOn needle (x:xs) = first (x:) $ breakOn needle xs
+
+
+

lib/GHCup/Utils/String/QQ.hs

@@ -44,15 +44,14 @@ import           Language.Haskell.TH.Quote
 -- The pattern portion is undefined.
 s :: QuasiQuoter
 s = QuasiQuoter
-  (\s' -> case and $ fmap isAscii s' of
+  (\s' -> case all isAscii s' of
     True  -> (\a -> [|fromString a|]) . trimLeadingNewline . removeCRs $ s'
     False -> fail "Not ascii"
   )
-  (error "Cannot use q as a pattern")
+  (error "Cannot use s as a pattern")
-  (error "Cannot use q as a type")
+  (error "Cannot use s as a type")
-  (error "Cannot use q as a dec")
+  (error "Cannot use s as a dec")
  where
   removeCRs = filter (/= '\r')
   trimLeadingNewline ('\n' : xs) = xs
   trimLeadingNewline xs          = xs
-

lib/GHCup/Version.hs

@@ -24,6 +24,9 @@ import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T
 
 -- | This reflects the API version of the YAML.
+--
+-- Note that when updating this, CI requires that the file exsists AND the same file exists at
+-- 'https://www.haskell.org/ghcup/exp/ghcup-<ver>.yaml' with some newlines added.
 ghcupURL :: URI
 ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.6.yaml|]
 

scripts/bootstrap/bootstrap-haskell

@@ -3,6 +3,7 @@
 # Main settings:
 #   * BOOTSTRAP_HASKELL_NONINTERACTIVE - any nonzero value for noninteractive installation
 #   * BOOTSTRAP_HASKELL_NO_UPGRADE - any nonzero value to not trigger the upgrade
+#   * BOOTSTRAP_HASKELL_MINIMAL - any nonzero value to only install ghcup
 #   * GHCUP_USE_XDG_DIRS - any nonzero value to respect The XDG Base Directory Specification
 #   * BOOTSTRAP_HASKELL_VERBOSE - any nonzero value for more verbose installation
 #   * BOOTSTRAP_HASKELL_GHC_VERSION - the ghc version to install
@@ -20,7 +21,7 @@
 
 plat="$(uname -s)"
 arch=$(uname -m)
-ghver="0.1.16.2"
+ghver="0.1.17"
 base_url="https://downloads.haskell.org/~ghcup"
 
 export GHCUP_SKIP_UPDATE_CHECK=yes
@@ -51,41 +52,57 @@ esac
 
 
 die() {
-    (>&2 printf "\\033[0;31m%s\\033[0m\\n" "$1")
+    if [ -n "${NO_COLOR}" ] ; then
+        (>&2 printf "%s\\n" "$1")
+    else
+        (>&2 printf "\\033[0;31m%s\\033[0m\\n" "$1")
+    fi
     exit 2
 }
 
 warn() {
-	case "${plat}" in
+    if [ -n "${NO_COLOR}" ] ; then
-			MSYS*|MINGW*)
+        printf "%s\\n" "$1"
-				echo -e "\\033[0;35m$1\\033[0m"
+    else
-				;;
+        case "${plat}" in
-			*)
+                MSYS*|MINGW*)
-				printf "\\033[0;35m%s\\033[0m\\n" "$1"
+                    echo -e "\\033[0;35m$1\\033[0m"
-				;;
+                    ;;
-	esac
+                *)
+                    printf "\\033[0;35m%s\\033[0m\\n" "$1"
+                    ;;
+        esac
+    fi
 }
 
 yellow() {
-	case "${plat}" in
+    if [ -n "${NO_COLOR}" ] ; then
-			MSYS*|MINGW*)
+        printf "%s\\n" "$1"
-				echo -e "\\033[0;33m$1\\033[0m"
+    else
-				;;
+        case "${plat}" in
-			*)
+                MSYS*|MINGW*)
-				printf "\\033[0;33m%s\\033[0m\\n" "$1"
+                    echo -e "\\033[0;33m$1\\033[0m"
-				;;
+                    ;;
-	esac
+                *)
+                    printf "\\033[0;33m%s\\033[0m\\n" "$1"
+                    ;;
+        esac
+    fi
 }
 
 green() {
-	case "${plat}" in
+    if [ -n "${NO_COLOR}" ] ; then
-			MSYS*|MINGW*)
+        printf "%s\\n" "$1"
-				echo -e "\\033[0;32m$1\\033[0m"
+    else
-				;;
+        case "${plat}" in
-			*)
+                MSYS*|MINGW*)
-				printf "\\033[0;32m%s\\033[0m\\n" "$1"
+                    echo -e "\\033[0;32m$1\\033[0m"
-				;;
+                    ;;
-	esac
+                *)
+                    printf "\\033[0;32m%s\\033[0m\\n" "$1"
+                    ;;
+        esac
+    fi
 }
 
 edo() {
@@ -99,7 +116,7 @@ eghcup() {
 _eghcup() {
 	if [ -n "${BOOTSTRAP_HASKELL_YAML}" ] ; then
 		args="-s ${BOOTSTRAP_HASKELL_YAML}"
-	fi 
+	fi
     if [ -z "${BOOTSTRAP_HASKELL_VERBOSE}" ] ; then
         "${GHCUP_BIN}/ghcup" ${args} "$@"
     else
@@ -175,7 +192,15 @@ download_ghcup() {
 					_url=${base_url}/${ghver}/armv7-linux-ghcup-${ghver}
 					;;
 				aarch64|arm64|armv8l)
-					_url=${base_url}/${ghver}/aarch64-linux-ghcup-${ghver}
+					# we could be in a 32bit docker container, in which
+					# case uname doesn't give us what we want
+					if [ "$(getconf LONG_BIT)" = "32" ] ; then
+						_url=${base_url}/${ghver}/armv7-linux-ghcup-${ghver}
+					elif [ "$(getconf LONG_BIT)" = "64" ] ; then
+						_url=${base_url}/${ghver}/aarch64-linux-ghcup-${ghver}
+					else
+						die "Unknown long bit size: $(getconf LONG_BIT)"
+					fi
 					;;
 				*) die "Unknown architecture: ${arch}"
 					;;
@@ -292,16 +317,7 @@ ask_bashrc() {
 
 			read -r bashrc_answer </dev/tty
 		else
-			# On windows .bashrc isn't an important user config, so we adjust it
+			return 0
-			# always. On other platforms, let's be a bit more conservative.
-			case "${plat}" in
-					MSYS*|MINGW*)
-						return 1
-						;;
-					*)
-						return 0
-						;;
-			esac
 		fi
 		case $bashrc_answer in
 			[Pp]* | "")
@@ -371,6 +387,13 @@ adjust_bashrc() {
 								echo "[[ -f ~/.bashrc ]] && source ~/.bashrc # ghcup-env" >> "${HOME}/.bash_profile"
 							fi
 							;;
+						MSYS*|MINGW*)
+							if [ ! -e "${HOME}/.bash_profile" ] ; then
+								echo '# generated by ghcup' > "${HOME}/.bash_profile"
+								echo 'test -f ~/.profile && . ~/.profile' >> "${HOME}/.bash_profile"
+								echo 'test -f ~/.bashrc && . ~/.bashrc' >> "${HOME}/.bash_profile"
+							fi
+							;;
 					esac
 					break ;;
 
@@ -398,7 +421,7 @@ warn_path() {
 	echo
 	[ -n "$1" ] && warn "$1"
 	yellow "In order to run ghc and cabal, you need to adjust your PATH variable."
-	yellow "To do so, you may want run 'source $GHCUP_DIR/env' in your current terminal"
+	yellow "To do so, you may want to run 'source $GHCUP_DIR/env' in your current terminal"
 	yellow "session as well as your shell configuration (e.g. ~/.bashrc)."
 
 }
@@ -591,10 +614,12 @@ ask_bashrc
 ask_bashrc_answer=$?
 ask_cabal_config_init
 ask_cabal_config_init_answer=$?
-ask_hls
+if [ -z "${BOOTSTRAP_HASKELL_MINIMAL}" ] ; then
-ask_hls_answer=$?
+	ask_hls
-ask_stack
+	ask_hls_answer=$?
-ask_stack_answer=$?
+	ask_stack
+	ask_stack_answer=$?
+fi
 
 edo mkdir -p "${GHCUP_BIN}"
 
@@ -620,14 +645,30 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
     read -r answer </dev/tty
 fi
 
-eghcup --cache install ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
+if [ -z "${BOOTSTRAP_HASKELL_MINIMAL}" ] ; then
+	eghcup --cache install ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
 
-eghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
+	eghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
-eghcup --cache install cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
+	eghcup --cache install cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
 
-do_cabal_config_init $ask_cabal_config_init_answer
+	do_cabal_config_init $ask_cabal_config_init_answer
 
-edo cabal new-update
+	edo cabal new-update
+else # don't install ghc and cabal
+	case "${plat}" in
+			MSYS*|MINGW*)
+				# need to bootstrap cabal to initialize config on windows
+				# we'll remove it afterwards
+				tmp_dir="$(mktemp -d)"
+				eghcup --cache install cabal -i "${tmp_dir}" "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
+				PATH="${tmp_dir}:$PATH" do_cabal_config_init $ask_cabal_config_init_answer
+				rm "${tmp_dir}/cabal"
+				unset tmp_dir
+				;;
+			*)
+				;;
+	esac
+fi
 
 case $ask_hls_answer in
 	1)
@@ -652,4 +693,3 @@ _done
 )
 
 # vim: tabstop=4 shiftwidth=4 expandtab
-

scripts/bootstrap/bootstrap-haskell.ps1

@@ -15,24 +15,26 @@
 param (
     # Run an interactive installation
     [switch]$Interactive,
-    # Specify the install root (default: 'C:\')
+    # Do minimal installation of ghcup and msys2 only
-    [string]$InstallDir,
+    [switch]$Minimal,
-    # Instead of installing a new MSys2, use an existing installation
-    [string]$ExistingMsys2Dir,
-    # Specify the cabal root directory (default: '$InstallDir\cabal')
-    [string]$CabalDir,
-    # Overwrite (or rather backup) a previous install
-    [switch]$Overwrite,
-    # Specify the bootstrap url (default: 'https://www.haskell.org/ghcup/sh/bootstrap-haskell')
-    [string]$BootstrapUrl,
     # Run the final bootstrap script via 'bash' instead of a full newly spawned msys2 shell
     [switch]$InBash,
+    # Overwrite (or rather backup) a previous install
+    [switch]$Overwrite,
+    # Skip adjusting cabal.config with mingw paths
+    [switch]$NoAdjustCabalConfig,
     # Whether to install stack as well
     [switch]$InstallStack,
     # Whether to install hls as well
     [switch]$InstallHLS,
-    # Skip adjusting cabal.config with mingw paths
+    # Specify the bootstrap url (default: 'https://www.haskell.org/ghcup/sh/bootstrap-haskell')
-    [switch]$NoAdjustCabalConfig
+    [string]$InstallDir,
+    # Instead of installing a new MSys2, use an existing installation
+    [string]$BootstrapUrl,
+    # Specify the install root (default: 'C:\')
+    [string]$ExistingMsys2Dir,
+    # Specify the cabal root directory (default: '$InstallDir\cabal')
+    [string]$CabalDir
 )
 
 $Silent = !$Interactive
@@ -180,7 +182,7 @@ elevated command prompt:
 
 if ($GhcupBasePrefixEnv) {
   $defaultGhcupBasePrefix = $GhcupBasePrefixEnv
-} else {
+} elseif (!($InstallDir)) {
   $partitions = Get-CimInstance win32_logicaldisk
   $defaultGhcupBasePrefix = $null
   foreach ($p in $partitions){
@@ -209,10 +211,10 @@ if ($Silent -and !($InstallDir)) {
   $GhcupBasePrefix = $defaultGhcupBasePrefix
 } elseif ($InstallDir) {
   if (!(Test-Path -LiteralPath ('{0}' -f $InstallDir) -IsValid)) {
-    Print-Msg -color Red -msg "Not a valid directory!"
+    Print-Msg -color Red -msg "Not a valid directory! (InstallDir)"
     Exit 1
   } elseif (!(Split-Path -IsAbsolute -Path "$InstallDir")) {
-    Print-Msg -color Red -msg "Non-absolute Path specified!"
+    Print-Msg -color Red -msg "Non-absolute Path specified! (InstallDir)"
     Exit 1
   } else {
     $GhcupBasePrefix = $InstallDir
@@ -243,7 +245,20 @@ $null = [Environment]::SetEnvironmentVariable("GHCUP_INSTALL_BASE_PREFIX", $Ghcu
 
 
 $GhcupDir = ('{0}\ghcup' -f $GhcupBasePrefix)
-$MsysDir = ('{0}\msys64' -f $GhcupDir)
+if ($ExistingMsys2Dir) {
+  if (!(Test-Path -LiteralPath ('{0}' -f $ExistingMsys2Dir) -IsValid)) {
+    Print-Msg -color Red -msg "Not a valid directory! (ExistingMsys2Dir)"
+    Exit 1
+  } elseif (!(Split-Path -IsAbsolute -Path "$ExistingMsys2Dir")) {
+    Print-Msg -color Red -msg "Non-absolute Path specified! (ExistingMsys2Dir)"
+    Exit 1
+  } else {
+	$MsysDir = $ExistingMsys2Dir
+  }
+} else {
+	$MsysDir = ('{0}\msys64' -f $GhcupDir)
+}
+
 $Bash = ('{0}\usr\bin\bash' -f $MsysDir)
 if (!($BootstrapUrl)) {
   $BootstrapUrl = 'https://www.haskell.org/ghcup/sh/bootstrap-haskell'
@@ -398,6 +413,7 @@ if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
 
     Print-Msg -msg 'Setting default home directory...'
     Exec "$Bash" '-lc' "sed -i -e 's/db_home:.*$/db_home: windows/' /etc/nsswitch.conf"
+
   } elseif ($msys2Decision -eq 1) {
     Print-Msg -color Yellow -msg 'Skipping MSys2 installation.'
     while ($true) {
@@ -529,10 +545,14 @@ if (!($NoAdjustCabalConfig)) {
   $AdjustCabalConfigExport = 'export BOOTSTRAP_HASKELL_ADJUST_CABAL_CONFIG=1 ;'
 }
 
+if ($Minimal) {
+  $MinimalExport = 'export BOOTSTRAP_HASKELL_MINIMAL=1 ;'
+}
+
 if ((Get-Process -ID $PID).ProcessName.StartsWith("bootstrap-haskell") -Or $InBash) {
-  Exec "$Bash" '-lc' ('{4} {6} {7} {8} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport)
+  Exec "$Bash" '-lc' ('{4} {6} {7} {8} {9} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport, $MinimalExport)
 } else {
-  Exec "$Msys2Shell" '-mingw64' '-mintty' '-c' ('{4} {6} {7} {8} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; trap ''echo Press any key to exit && read -n 1 && exit'' 2 ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash ; echo ''Press any key to exit'' && read -n 1' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport)
+  Exec "$Msys2Shell" '-mingw64' '-mintty' '-c' ('{4} {6} {7} {8} {9} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; trap ''echo Press any key to exit && read -n 1 && exit'' 2 ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash ; echo ''Press any key to exit'' && read -n 1' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport, $MinimalExport)
 }
 
 

stack.yaml

@@ -4,26 +4,24 @@ packages:
   - .
 
 extra-deps:
-  - git: https://github.com/hasufell/text-conversions.git
+  - git: https://github.com/bgamari/terminal-size
-    commit: 9abf0e5e5664a3178367597c32db19880477a53c
+    commit: 34ea816bd63f75f800eedac12c6908c6f3736036
 
-  - git: https://github.com/Bodigrim/tar
+  - git: https://github.com/hasufell/libarchive
-    commit: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
+    commit: 8587aab78dd515928024ecd82c8f215e06db85cd
-
-  - git: https://github.com/jtdaugherty/brick.git
-    commit: b3b96cfe66dfd398d338e3feb2b6855e66a35190
 
   - IfElse-0.85@sha256:6939b94acc6a55f545f63a168a349dd2fbe4b9a7cca73bf60282db5cc6aa47d2,445
   - ascii-string-1.0.1.4@sha256:fa34f1d9ba57e8e89c0d4c9cef5e01ba32cb2d4373d13f92dcc0b531a6c6749b,2582
   - base16-bytestring-0.1.1.7@sha256:0021256a9628971c08da95cb8f4d0d72192f3bb8a7b30b55c080562d17c43dd3,2231
+  - brick-0.64@sha256:f03fa14607c22cf48af99e24c44f79a0fb073f7ec229f15e969fed9ff73c93f6,16530
   - brotli-0.0.0.0@sha256:2bf383a4cd308745740986be0b18381c5a0784393fe69b91456aacb2d603de46,2964
   - brotli-streams-0.0.0.0@sha256:1af1e22f67b8bfd6ad0d05e61825e7a178d738f689ebbb21c1aab5f1bbcae176,2331
   - chs-cabal-0.1.1.0@sha256:20ec6a9fb5ab6991f1a4adf157c537bd5d3b98d08d3c09c387c954c7c50bd011,1153
   - chs-deps-0.1.0.0@sha256:0cdada6d2c682c41b20331b8c63c2ecfc7e806928585195fd544c9d41f3074fd,2496
   - composition-prelude-3.0.0.2@sha256:1ffed216bd28d810fce0b5be83a661e2a892696d73b3f8de5c0f5edb9b5f0090,1216
-  - haskus-utils-data-1.3@sha256:f62c4e49021b463185d043f7b69c727b63af641a71d7edd582d9f4f98e80e500,1466
+  - haskus-utils-data-1.4@sha256:bfa94363b94b14779edd6834fbd59dbb847c3d7b8f48e3844f456ffdc077da4a,1466
   - haskus-utils-types-1.5.1@sha256:991c472f4e751e2f0d7aab6ad4220ef151d6160876dcf0511bbf876bbd432020,1298
-  - haskus-utils-variant-3.0@sha256:8d51e45d3b664e61ccc25a58b37c0ccc4ee7537138b9fee21cd15c356906dd34,2159
+  - haskus-utils-variant-3.1@sha256:e602dd23e068c98d03c1027af20503addef8df6368577622453f44ccabea2a5b,2159
   - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
   - hpath-posix-0.13.3@sha256:abe472cf16bccd3a8b8814865ed3551a728fde0f3a2baea2acc03023bec6c565,1615
   - hspec-2.7.10@sha256:c9e82c90086acebac576552a06f3cabd249bba048edd1667c7fae0b1313d5bce,1712
@@ -31,13 +29,12 @@ extra-deps:
   - hspec-discover-2.7.10@sha256:d08bf5dd785629f589571477d9beb7cd91529471bd89f39517c1cb4b9b38160f,2184
   - hspec-golden-aeson-0.9.0.0@sha256:aa17274114026661ba4dfc9c60c230673c8f408bd86482fd611d2d5cb6aff996,2179
   - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
-  - libarchive-3.0.2.1@sha256:40ebf2a278e585802427bc58826867208bb33822f63d56107a1fcc3ca04d691d,10990
   - lzma-static-5.2.5.3@sha256:2758ee58c35992fcf7db78e98684c357a16a82fa2a4e7c352a6c210c08c555d8,7308
-  - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
   - optics-0.4@sha256:9fb69bf0195b8d8f1f8cd0098000946868b8a3c3ffb51e5b64f79fc600c3eb4c,6568
   - optics-core-0.4@sha256:59e04aebca536bd011ae50c781937f45af4c1456af1eb9fb578f9a69eee293cd,4995
   - optics-extra-0.4@sha256:b9914f38aa7d5c92f231060d9168447f9f5a367c07df9bf47a003e3e786d5e05,3432
   - optics-th-0.4@sha256:7c838b5b1d6998133bf8f0641c36197ed6cb468dc69515e1952f33f0bbe8e11d,2009
+  - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
   - primitive-0.7.1.0@sha256:29de6bfd0cf8ba023ceb806203dfbec0e51e3524e75ffe41056f70b4229c6f0f,2728
   - regex-posix-clib-2.7
   - streamly-0.7.3@sha256:ad2a488fe802692ed47cab9fd0416c2904aac9e51cf2d8aafd1c3a40064c42f5,27421
@@ -45,7 +42,6 @@ extra-deps:
   - streamly-posix-0.1.0.1@sha256:5d89b806281035d34020387ed99dde1ddab282c7ed66df3b7cd010b38fd3517b,2138
   - strict-base-0.4.0.0@sha256:2ff4e43cb95eedf2995558d7fc34d19362846413dd39e6aa6a5b3ea8228fef9f,1248
   - xor-0.0.1.0@sha256:f8362b4a68562b9afbcd727ff64c1a303970df3a032e0033d2f4c094c3501df3,2243
-  - zip-1.7.1@sha256:0ce03d0fbffba47c1ab6fbb9166f8ba5373d828d78587df21b7e9d7bb150f929,3918
 
 flags:
   http-io-streams:
@@ -57,7 +53,21 @@ flags:
   regex-posix:
     _regex-posix-clib: true
 
+  aeson-pretty:
+    lib-only: true
+
+  cabal-plan:
+    exe: false
+
 ghc-options:
   "$locals": -O2
   streamly: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
   ghcup: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+build:
+  test: true
+  test-arguments:
+    no-run-tests: true
+  bench: true
+  benchmark-opts:
+    no-run-benchmarks: true

test/GHCup/ArbitraryTypes.hs

@@ -66,7 +66,7 @@ instance Arbitrary ByteString where
     ---------------------
 
 instance Arbitrary Scheme where
-  arbitrary = oneof [ pure (Scheme "http"), pure (Scheme "https") ]
+  arbitrary = elements [ Scheme "http", Scheme "https" ]
 
 instance Arbitrary Host where
   arbitrary = genericArbitrary

test/GHCup/Types/JSONSpec.hs

@@ -13,4 +13,5 @@ import           Test.Hspec
 
 spec :: Spec
 spec = do
-  roundtripAndGoldenSpecs (Proxy @GHCupInfo)
+  roundtripAndGoldenSpecsWithSettings (defaultSettings { goldenDirectoryOption = CustomDirectoryName "test/golden" }) (Proxy @GHCupInfo)
+

www/ghcup.css

@@ -174,7 +174,17 @@ span.code {
     line-height: 2rem;
 }
 
+#help {
+    margin-bottom: 0px !important;
+}
+
+#collective {
+    margin-top: 1em !important;
+    margin-bottom: 0px !important;
+}
+
 #about {
+    margin-top: 0.5em !important;
     font-size: 16px;
     line-height: 2em;
 }

www/index.html

@@ -137,9 +137,14 @@
 
       </div>
 
-      <p>
+      <p id="help">
 	  Need help? Ask on <a href="https://kiwiirc.com/nextclient/irc.libera.chat/?nick=Guest%7C?#haskell,#haskell-ghcup"><img src="irc.svg" height="18px" alt="" />IRC</a>, <a href="https://discord.gg/pKYf3zDQU7"><img src="Discord-Logo-Black.svg" height="18px" alt="" />Discord</a>, <a href="https://app.element.io/#/room/#haskell-tooling:matrix.org"><img src="Matrix_logo.svg" height="25px" alt="" style="top:5px;position:relative;" /></a> or <a href="https://gitlab.haskell.org/haskell/ghcup-hs/issues">report a bug <img src="Octicons-bug.svg" height="18px" alt="" /></a>.
       </p>
+      <p id="collective">
+		<a id="collective" href="https://opencollective.com/ghcup#category-CONTRIBUTE" target="_blank">
+			<img src="https://opencollective.com/webpack/donate/button@2x.png?color=blue" width=200 />
+		</a>
+      </p>
 
       <p id="about">
         <img src="haskell-logo.svg" alt="" />