Fix build on FreeBSD

Related: https://gitlab.haskell.org/ghc/ghc/-/issues/19948

.gitignore

@@ -1,2 +1,15 @@
+.ghci
+.vim
+codex.tags
 dist-newstyle/
+cabal.project.local
 .stack-work/
+bin/
+/*.prof
+/*.ps
+/*.hp
+tags
+TAGS
+/tmp/
+.entangled
+release/

.gitlab-ci.yml

@@ -0,0 +1,415 @@
+stages:
+  - hlint
+  - test
+  - release
+
+variables:
+  GIT_SSL_NO_VERIFY: "1"
+
+  # Commit of ghc/ci-images repository from which to pull Docker images
+  DOCKER_REV: 1ac7f435c9312f10422a82d304194778378e2a1a
+
+############################################################
+# CI Step
+############################################################
+
+.debian:
+  image: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb9:$DOCKER_REV"
+  tags:
+    - x86_64-linux
+  variables:
+    OS: "LINUX"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.alpine:64bit:
+  image: "alpine:3.12"
+  tags:
+    - x86_64-linux
+  variables:
+    OS: "LINUX"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.alpine:32bit:
+  image: "i386/alpine:3.12"
+  tags:
+    - x86_64-linux
+  variables:
+    OS: "LINUX"
+    ARCH: "32"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.linux:armv7:
+  image: "arm32v7/fedora"
+  tags:
+    - armv7-linux
+  variables:
+    OS: "LINUX"
+    ARCH: "ARM"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.linux:aarch64:
+  image: "arm64v8/fedora"
+  tags:
+    - aarch64-linux
+  variables:
+    OS: "LINUX"
+    ARCH: "ARM64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.darwin:
+  tags:
+    - x86_64-darwin
+  variables:
+    OS: "DARWIN"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.freebsd:
+  tags:
+    - x86_64-freebsd
+  variables:
+    OS: "FREEBSD"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.windows:
+  tags:
+    - new-x86_64-windows
+  variables:
+    OS: "WINDOWS"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.root_cleanup:
+  after_script:
+    - bash ./.gitlab/after_script.sh
+
+.test_ghcup_version:
+  script:
+    - bash ./.gitlab/script/ghcup_version.sh
+  variables:
+    JSON_VERSION: "0.0.5"
+  artifacts:
+    expire_in: 2 week
+    paths:
+      - golden
+    when: on_failure
+
+.test_ghcup_version:linux:
+  extends:
+    - .test_ghcup_version
+    - .debian
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps.sh
+
+.test_ghcup_version:linux32:
+  extends:
+    - .test_ghcup_version
+    - .alpine:32bit
+  before_script:
+    - ./.gitlab/before_script/linux/alpine/install_deps.sh
+
+.test_ghcup_version:armv7:
+  extends:
+    - .test_ghcup_version
+    - .linux:armv7
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
+
+.test_ghcup_version:aarch64:
+  extends:
+    - .test_ghcup_version
+    - .linux:aarch64
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
+
+.test_ghcup_version:darwin:
+  extends:
+    - .test_ghcup_version
+    - .darwin
+    - .root_cleanup
+  before_script:
+    - ./.gitlab/before_script/darwin/install_deps.sh
+
+.test_ghcup_version:freebsd:
+  extends:
+    - .test_ghcup_version
+    - .freebsd
+    - .root_cleanup
+  before_script:
+    - ./.gitlab/before_script/freebsd/install_deps.sh
+
+.test_ghcup_version:windows:
+  extends:
+    - .test_ghcup_version
+    - .windows
+    - .root_cleanup
+  before_script:
+    - set CABAL_DIR="$CI_PROJECT_DIR/cabal"
+    - bash ./.gitlab/before_script/windows/install_deps.sh
+
+.release_ghcup:
+  script:
+    - bash ./.gitlab/script/ghcup_release.sh
+  artifacts:
+    expire_in: 2 week
+    paths:
+      - out
+  only:
+    - tags
+  variables:
+    JSON_VERSION: "0.0.5"
+
+######## stack test ########
+
+test:linux:stack:
+  stage: test
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_minimal.sh
+  script:
+    - ./.gitlab/script/ghcup_stack.sh
+  extends:
+    - .debian
+  needs: []
+
+######## bootstrap test ########
+
+test:linux:bootstrap_script:
+  stage: test
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_minimal.sh
+  script:
+    - ./.gitlab/script/ghcup_bootstrap.sh
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  extends:
+    - .debian
+  needs: []
+
+######## linux test ########
+
+test:linux:recommended:
+  stage: test
+  extends: .test_ghcup_version:linux
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  needs: []
+
+test:linux:latest:
+  stage: test
+  extends: .test_ghcup_version:linux
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  needs: []
+
+######## linux 32bit test ########
+
+test:linux:recommended:32bit:
+  stage: test
+  extends: .test_ghcup_version:linux32
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.2.0.0"
+  needs: []
+
+######## arm tests ########
+
+test:linux:recommended:armv7:
+  stage: test
+  extends: .test_ghcup_version:armv7
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  when: manual
+  needs: []
+
+test:linux:recommended:aarch64:
+  stage: test
+  extends: .test_ghcup_version:aarch64
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  when: manual
+  needs: []
+
+######## darwin test ########
+
+test:mac:recommended:
+  stage: test
+  extends: .test_ghcup_version:darwin
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  needs: []
+
+test:mac:latest:
+  stage: test
+  extends: .test_ghcup_version:darwin
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  needs: []
+
+
+######## freebsd test ########
+
+test:freebsd:recommended:
+  stage: test
+  extends: .test_ghcup_version:freebsd
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  allow_failure: true # freebsd runners are unreliable
+  when: manual
+  needs: []
+
+test:freebsd:latest:
+  stage: test
+  extends: .test_ghcup_version:freebsd
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  allow_failure: true # freebsd runners are unreliable
+  when: manual
+  needs: []
+
+######## windows test ########
+
+test:windows:recommended:
+  stage: test
+  extends: .test_ghcup_version:windows
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+  needs: []
+
+######## linux release ########
+
+release:linux:64bit:
+  stage: release
+  needs: ["test:linux:recommended", "test:linux:latest"]
+  extends:
+    - .alpine:64bit
+    - .release_ghcup
+  before_script:
+    - ./.gitlab/before_script/linux/alpine/install_deps.sh
+  variables:
+    ARTIFACT: "x86_64-linux-ghcup"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+
+
+release:linux:32bit:
+  stage: release
+  needs: ["test:linux:recommended:32bit"]
+  extends:
+    - .alpine:32bit
+    - .release_ghcup
+  before_script:
+    - ./.gitlab/before_script/linux/alpine/install_deps.sh
+  variables:
+    ARTIFACT: "i386-linux-ghcup"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.2.0.0"
+
+release:linux:armv7:
+  stage: release
+  needs: ["test:linux:recommended:armv7"]
+  extends:
+    - .linux:armv7
+    - .release_ghcup
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
+  variables:
+    ARTIFACT: "armv7-linux-ghcup"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+
+release:linux:aarch64:
+  stage: release
+  needs: ["test:linux:recommended:aarch64"]
+  extends:
+    - .linux:aarch64
+    - .release_ghcup
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
+  variables:
+    ARTIFACT: "aarch64-linux-ghcup"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+
+######## darwin release ########
+
+release:darwin:
+  stage: release
+  needs: ["test:mac:recommended", "test:mac:latest"]
+  extends:
+    - .darwin
+    - .release_ghcup
+    - .root_cleanup
+  before_script:
+    - ./.gitlab/before_script/darwin/install_deps.sh
+  variables:
+    ARTIFACT: "x86_64-apple-darwin-ghcup"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+    MACOSX_DEPLOYMENT_TARGET: "10.7"
+
+
+######## freebsd release ########
+
+release:freebsd:
+  stage: release
+  needs: ["test:freebsd:recommended", "test:freebsd:latest"]
+  extends:
+    - .freebsd
+    - .release_ghcup
+    - .root_cleanup
+  before_script:
+    - ./.gitlab/before_script/freebsd/install_deps.sh
+  variables:
+    ARTIFACT: "x86_64-portbld-freebsd-ghcup"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+
+######## windows release ########
+
+release:windows:
+  stage: release
+  needs: ["test:windows:recommended"]
+  extends:
+    - .windows
+    - .release_ghcup
+    - .root_cleanup
+  before_script:
+    - bash ./.gitlab/before_script/windows/install_deps.sh
+  variables:
+    ARTIFACT: "x86_64-mingw64-ghcup"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+
+######## hlint ########
+
+hlint:
+  stage: hlint
+  extends:
+    - .alpine:64bit
+  before_script:
+    - ./.gitlab/before_script/linux/alpine/install_deps.sh
+  script:
+    - ./.gitlab/script/hlint.sh
+  variables:
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"
+    JSON_VERSION: "0.0.4"
+  allow_failure: true
+  artifacts:
+    expire_in: 2 week
+    paths:
+      - report.html
+    when: on_failure

.gitlab/after_script.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+set -eux
+
+BUILD_DIR=$CI_PROJECT_DIR
+echo "Cleaning $BUILD_DIR"
+cd $HOME
+test -n "$BUILD_DIR"
+shopt -s extglob
+rm -Rf "$BUILD_DIR"/!(out)
+if [ "${OS}" = "WINDOWS" ] ; then
+	rm -Rf /c/ghcup
+fi
+
+exit 0

.gitlab/before_script/darwin/install_deps.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup > ./ghcup-bin
+chmod +x ghcup-bin
+
+./ghcup-bin upgrade -i -f
+./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}
+
+exit 0

.gitlab/before_script/freebsd/install_deps.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+set -eux
+
+# pkg install --force --yes --no-repo-update curl gcc gmp gmake ncurses perl5 libffi libiconv
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+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 install ${GHC_VERSION}
+./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}
+
+exit 0

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

@@ -0,0 +1,54 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+apk add --no-cache \
+	curl \
+	gcc \
+	g++ \
+	binutils \
+	binutils-gold \
+	bsd-compat-headers \
+	gmp-dev \
+	ncurses-dev \
+	libffi-dev \
+	make \
+	xz \
+	tar \
+	perl
+
+if [ "${ARCH}" = "32" ] ; then
+	curl -sSfL https://downloads.haskell.org/ghcup/i386-linux-ghcup > ./ghcup-bin
+else
+	curl -sSfL https://downloads.haskell.org/ghcup/x86_64-linux-ghcup > ./ghcup-bin
+fi
+chmod +x ghcup-bin
+./ghcup-bin upgrade -i -f
+./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}
+
+# utils
+apk add --no-cache \
+	bash \
+	git
+
+## Package specific
+apk add --no-cache \
+	zlib \
+	zlib-dev \
+	zlib-static \
+	bzip2 \
+	bzip2-dev \
+	bzip2-static \
+	gmp \
+	gmp-dev \
+	openssl-dev \
+	openssl-libs-static \
+	xz \
+	xz-dev \
+	ncurses-static
+

.gitlab/before_script/linux/install_deps.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+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
+
+curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup > ./ghcup-bin
+chmod +x ghcup-bin
+
+./ghcup-bin upgrade -i -f
+./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}
+

.gitlab/before_script/linux/install_deps_manual.sh

@@ -0,0 +1,64 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+ednf() {
+	case "${ARCH}" in
+		"ARM")
+			sudo dnf -y --forcearch armv7hl "$@"
+			;;
+		"ARM64")
+			sudo dnf -y --forcearch aarch64 "$@"
+			;;
+		*) exit 1 ;;
+	esac
+}
+
+ednf update
+ednf install gcc gcc-c++ gmp gmp-devel make ncurses ncurses-devel xz xz-devel perl zlib zlib-devel openssl-devel openssl-libs openssl libffi libffi-devel lbzip2 lbzip2-utils bzip2-devel
+if [ "${ARCH}" = "ARM64" ] ; then
+	ednf install numactl numactl-libs numactl-devel
+fi
+ednf install bash wget curl git tar
+ednf install llvm9.0 llvm9.0-devel llvm9.0-libs llvm9.0-static
+
+case "${ARCH}" in
+	"ARM")
+		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 -O "${ghc_url}"
+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

.gitlab/before_script/linux/install_deps_minimal.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+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

.gitlab/before_script/windows/install_deps.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}" "${CABAL_DIR}"
+
+rm -rf /c/ghcup
+mkdir -p /c/ghcup
+
+CI_PROJECT_DIR=$(pwd)
+curl -o ghcup.exe https://downloads.haskell.org/~ghcup/tmp/x86_64-mingw64-ghcup-5.exe
+chmod +x ghcup.exe
+
+./ghcup.exe install ${GHC_VERSION}
+./ghcup.exe set ${GHC_VERSION}
+./ghcup.exe install-cabal ${CABAL_VERSION}
+
+rm ./ghcup.exe
+
+exit 0

.gitlab/ghcup_env

@@ -0,0 +1,9 @@
+if [ "${OS}" = "WINDOWS" ] ; then
+	export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
+	export PATH="/c/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:$PATH"
+	export TMPDIR="$CI_PROJECT_DIR/tmp"
+fi

.gitlab/script/ghcup_bootstrap.sh

@@ -0,0 +1,30 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+ecabal() {
+	cabal "$@"
+}
+
+eghcup() {
+	ghcup -v -c -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml "$@"
+}
+
+git describe --always
+
+### build
+
+ecabal update
+
+export BOOTSTRAP_HASKELL_NONINTERACTIVE=yes
+export BOOTSTRAP_HASKELL_GHC_VERSION=$GHC_VERSION
+export BOOTSTRAP_HASKELL_CABAL_VERSION=$CABAL_VERSION
+
+./bootstrap-haskell
+
+[ "$(ghc --numeric-version)" = "${GHC_VERSION}" ]
+

.gitlab/script/ghcup_release.sh

@@ -0,0 +1,48 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+ecabal() {
+	cabal "$@"
+}
+
+git describe
+
+# build
+ecabal update
+
+(
+	cd /tmp
+	ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hspec-discover
+)
+
+if [ "${OS}" = "LINUX" ] ; then
+	if [ "${ARCH}" = "32" ] ; then
+		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui -ftar
+	elif [ "${ARCH}" = "64" ] ; then
+		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
+	else
+		ecabal build -w ghc-${GHC_VERSION} -ftui
+	fi
+elif [ "${OS}" = "FREEBSD" ] ; then
+	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib +bundled-c-zlib" --constraint="zip +disable-zstd" -ftui
+elif [ "${OS}" = "WINDOWS" ] ; then
+	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static"
+else
+	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
+fi
+
+mkdir out
+cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" .
+ver=$(./ghcup --numeric-version)
+if [ "${OS}" = "DARWIN" ] ; then
+	strip ./ghcup
+else
+	strip -s ./ghcup
+fi
+cp ghcup out/${ARTIFACT}-${ver}
+

.gitlab/script/ghcup_stack.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+git describe --always
+
+### build
+
+curl -L -O https://get.haskellstack.org/stable/linux-x86_64.tar.gz
+tar xf linux-x86_64.tar.gz
+cp stack-*-linux-*/stack "$CI_PROJECT_DIR"/.local/bin/stack
+chmod +x "$CI_PROJECT_DIR"/.local/bin/stack
+
+mkdir -p "$CI_PROJECT_DIR"/.stack_root
+export TAR_OPTIONS=--no-same-owner
+stack --allow-different-user --stack-root "$CI_PROJECT_DIR"/.stack_root build
+stack --allow-different-user --stack-root "$CI_PROJECT_DIR"/.stack_root test

.gitlab/script/ghcup_version.sh

@@ -0,0 +1,145 @@
+#!/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() {
+	if [ "${OS}" = "WINDOWS" ] ; then
+		ghcup -v -c -s file:/$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
+	else
+		ghcup -v -c -s file://$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml "$@"
+	fi
+}
+
+git describe --always
+
+### build
+
+ecabal update
+
+(
+	cd /tmp
+	ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hspec-discover
+)
+
+if [ "${OS}" = "DARWIN" ] ; then
+	ecabal build -w ghc-${GHC_VERSION} -ftui
+	ecabal test -w ghc-${GHC_VERSION} -ftui ghcup-test
+	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 test -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar ghcup-test
+		ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
+	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
+	fi
+elif [ "${OS}" = "FREEBSD" ] ; then
+	ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui --constraint="zip +disable-zstd"
+	ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui --constraint="zip +disable-zstd" ghcup-test
+	ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui --constraint="zip +disable-zstd"
+elif [ "${OS}" = "WINDOWS" ] ; then
+	ecabal build -w ghc-${GHC_VERSION}
+	ecabal test -w ghc-${GHC_VERSION} ghcup-test
+	ecabal haddock -w ghc-${GHC_VERSION}
+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
+fi
+
+
+cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" .
+cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup-gen')" .
+
+cp ./ghcup "$CI_PROJECT_DIR"/.local/bin/ghcup
+cp ./ghcup-gen "$CI_PROJECT_DIR"/.local/bin/ghcup-gen
+
+### cleanup
+
+rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
+
+
+### manual cli based testing
+
+
+ghcup-gen check -f ghcup-${JSON_VERSION}.yaml
+
+eghcup --numeric-version
+
+eghcup install ${GHC_VERSION}
+eghcup set ${GHC_VERSION}
+eghcup install-cabal ${CABAL_VERSION}
+
+cabal --version
+
+eghcup debug-info
+
+eghcup list
+eghcup list -t ghc
+eghcup list -t cabal
+
+ghc_ver=$(ghc --numeric-version)
+ghc --version
+ghci --version
+ghc-$(ghc --numeric-version) --version
+ghci-$(ghc --numeric-version) --version
+
+
+# test installing new ghc doesn't mess with currently set GHC
+# https://gitlab.haskell.org/haskell/ghcup-hs/issues/7
+if [ "${OS}" = "LINUX" ] ; then
+	eghcup --downloader=wget install 8.10.3
+else # test wget a bit
+	eghcup install 8.10.3
+fi
+[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
+eghcup set 8.10.3
+eghcup set 8.10.3
+[ "$(ghc --numeric-version)" = "8.10.3" ]
+eghcup set ${GHC_VERSION}
+[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
+eghcup rm 8.10.3
+[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
+
+if [ "${OS}" = "DARWIN" ] ; then
+	eghcup install hls
+	haskell-language-server-wrapper --version
+
+	eghcup install stack
+	stack --version
+elif [ "${OS}" = "LINUX" ] ; then
+	if [ "${ARCH}" = "64" ] ; then
+		eghcup install hls
+		haskell-language-server-wrapper --version
+
+		eghcup install stack
+		stack --version
+	fi
+fi
+
+
+eghcup rm $(ghc --numeric-version)
+
+# https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/116
+if [ "${OS}" = "LINUX" ] ; then
+	if [ "${ARCH}" = "64" ] ; then
+		eghcup install cabal -u https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-ubuntu-16.04.tar.xz 3.4.0.0-rc4
+		eghcup rm cabal 3.4.0.0-rc4
+	fi
+fi
+
+eghcup upgrade
+eghcup upgrade -f
+

.gitlab/script/hlint.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+ecabal() {
+	cabal --store-dir="$(pwd)"/.store "$@"
+}
+
+git describe
+
+ecabal update
+ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hlint
+
+hlint -r lib/ test/ 
+

.hlint.yaml

@@ -0,0 +1,83 @@
+# HLint configuration file
+# https://github.com/ndmitchell/hlint
+##########################
+
+# This file contains a template configuration file, which is typically
+# placed as .hlint.yaml in the root of your project
+
+
+# Warnings currently triggered by your code
+- ignore: {name: "Redundant bang pattern"}
+- ignore: {name: "Use camelCase"}
+- ignore: {name: "Use if"}
+- ignore: {name: "Use newtype instead of data"}
+- ignore: {name: "Use <$>"}
+- ignore: {name: "Use mapMaybe"}
+- ignore: {name: "Use const"}
+- ignore: {name: "Use list comprehension"}
+- ignore: {name: "Redundant multi-way if"}
+- ignore: {name: "Redundant lambda"}
+- ignore: {name: "Avoid lambda"}
+- ignore: {name: "Use uncurry"}
+- ignore: {name: "Use replicateM"}
+- ignore: {name: "Redundant irrefutable pattern"}
+
+
+# Specify additional command line arguments
+#
+# - arguments: [--color, --cpp-simple, -XQuasiQuotes]
+
+
+# Control which extensions/flags/modules/functions can be used
+#
+# - extensions:
+#   - default: false # all extension are banned by default
+#   - name: [PatternGuards, ViewPatterns] # only these listed extensions can be used
+#   - {name: CPP, within: CrossPlatform} # CPP can only be used in a given module
+#
+# - flags:
+#   - {name: -w, within: []} # -w is allowed nowhere
+#
+# - modules:
+#   - {name: [Data.Set, Data.HashSet], as: Set} # if you import Data.Set qualified, it must be as 'Set'
+#   - {name: Control.Arrow, within: []} # Certain modules are banned entirely
+#
+# - functions:
+#   - {name: unsafePerformIO, within: []} # unsafePerformIO can only appear in no modules
+
+
+# Add custom hints for this project
+#
+# Will suggest replacing "wibbleMany [myvar]" with "wibbleOne myvar"
+# - error: {lhs: "wibbleMany [x]", rhs: wibbleOne x}
+
+# The hints are named by the string they display in warning messages.
+# For example, if you see a warning starting like
+#
+# Main.hs:116:51: Warning: Redundant ==
+#
+# You can refer to that hint with `{name: Redundant ==}` (see below).
+
+# Turn on hints that are off by default
+#
+# Ban "module X(module X) where", to require a real export list
+# - warn: {name: Use explicit module export list}
+#
+# Replace a $ b $ c with a . b $ c
+# - group: {name: dollar, enabled: true}
+#
+# Generalise map to fmap, ++ to <>
+# - group: {name: generalise, enabled: true}
+
+
+# Ignore some builtin hints
+# - ignore: {name: Use let}
+# - ignore: {name: Use const, within: SpecialModule} # Only within certain modules
+
+
+# Define some custom infix operators
+# - fixity: infixr 3 ~^#^~
+
+
+# To generate a suitable file for HLint do:
+# $ hlint --default > .hlint.yaml

.travis.yml

@@ -1,5 +1,10 @@
 jobs:
   include:
+    - os: osx
+      osx_image: xcode8
+      language: generic
+      env: ARTIFACT=x86_64-apple-darwin-10.11-ghcup
+
     - os: osx
       osx_image: xcode10.1
       language: generic
@@ -10,15 +15,23 @@ jobs:
       language: generic
       env: ARTIFACT=x86_64-apple-darwin-10.14-ghcup
 
+  allow_failures:
+    - os: osx
+      osx_image: xcode8
+      language: generic
+      env: ARTIFACT=x86_64-apple-darwin-10.11-ghcup
+
+
 script: ".travis/build.sh"
 
 deploy:
   provider: releases
   api_key:
-    secure: GEQR+HIwMUql+tFU0LoKCCzG+IG1s5XVA4yp8xMFk0IPsNjHEMh6djYgNqsS6MnujzRulinZe69RyJMZHW3UbtVKWd1D5nsCKmAVfnU8VRbubaL55Bz7C2WI9UCYtKY0isVIQu3KkY+0a6LhdjSkbatO2hl9v0nFmN28q/RpEzsJTI4kyVhmCBflH4fL/QvXzfLuyOae7qsiZBVQXEhmySYktKifNMANSI1aU+kyZ3JgykqZogMK+g/fmcxxTe9MPYMsRQxae/xqdf87IQpmK8v9BRShvF0wq1gO8NY+/fEemAVIHi5CYhPgiLntUD/HFr6AT04LcHnaGryDn/PhkvHuDuZ4INYgBrdNMeGVTjT93N7OtXyh7c+AP3/51E8nM0SkSWCeP4P2fMMksdeOnKtPbhzlqgEM9tbRMILOj1LcjcqurU5ku+WEwZ7d1osTyNug7FVCO5Vb0q3NYnDF4UPXc/d5/2SB+SjJSMxRc52+BiKskHmOa96TXirL3eo6KVNaokQRKvbLw1fEjZvqYJuhPWBRDMalyYjc77poj4kzfVL9CYjtP7h6N5wFR7AtPsMz2n2fQf7J3N4+oqHK+83fOPGyy4FYPZojKNw+L2X/XYrfVscsY/1KbBjULgGIrdr4euYz+rRrTHixUYIvGclKOx+g3SHAOXFWhXlldvI=
+    secure: GQESg4TcYf3PQJRRaZV/kWS0hsF+OFnH2+EcwpgnIcfx4+aogMyprdh745KtBXe1FlFN1luKHksFjqceqhcg/xcNyeCJiSnLWMn4D/i4WUperEHseRBi5yZZCB1AvOjIlHrE4DS3a8pyEm1GV3G7CKY5Fu8jBjof2SnyENfd7fofhjtNHWmeFS+jBn8HRDf1YaSRYxzTw6uHLrPLsybfgQZVl7babMu/38Ghin0f5pz5OlNokzDxaubIYQHOZ7st7YndHJtBWWql/KualBWbMILy88dUVQBnbqQLP2P8d1ME8ILUjJVqz33HiRU0JzlEJyWfbvEjcJ6iD8M6n4nXTaxfu3i2UhhGsQ6SSBNKssMP4tji8nkNpMqG59wLQ/zhcetEm71fKkgJNrIMNllkqlWSo5K74IqqP9kiLg/qm8ipOJjui0gPk8tZXKcV+ztX1d1OVCapoLfiDM5l/0LLQXaTOXOV1x3e5LLQ/w2doNiH3eh5CV4II9dRu7owpaiiMBHMssmT0pH99jEeF6giHLKtt3y7l2GWoRLPdhsZZ54gxsaBxZt9GuypmkbNcr97CEnAVaWij5v0CF3w4rAWqy/tAxQpIDJOIOQBgmwG5WrBAKyKrFvEpBL5a8BPcRWJDvqKC83QeWpvPrEVdgJevC6ZN1MKzrb2SiPOwC2Kerc=
   file: $ARTIFACT
   on:
-    repo: hasufell/ghcup-hs
+    repo: haskell/ghcup-hs
     tags: true
   skip_cleanup: true
   draft: true
+

.travis/build.sh

@@ -1,22 +1,28 @@
-#/bin/sh
+#!/bin/sh
 
 set -ex
 
-## install ghc via old ghcup
-
 mkdir -p ~/.ghcup/bin
-curl https://gitlab.haskell.org/haskell/ghcup/raw/master/ghcup > ~/.ghcup/bin/ghcup
+curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup > ~/.ghcup/bin/ghcup
 chmod +x ~/.ghcup/bin/ghcup
 
 export PATH="$HOME/.ghcup/bin:$PATH"
 
-ghcup install 8.8.3
-ghcup install-cabal 3.2.0.0
-ghcup set 8.8.3
+ghcup install 8.10.4
+ghcup install-cabal 3.4.0.0
+ghcup set 8.10.4
 
 
 ## install ghcup
 
 cabal update
-cabal build -fcurl
-cp "$(cabal new-exec --verbose=0 --offline sh -- -c 'command -v ghcup')" "./${ARTIFACT}"
+
+(
+	cd /tmp
+	cabal install --installdir="$HOME"/.ghcup/bin hspec-discover
+)
+
+cabal build --constraint="zlib +static" --constraint="lzma +static" -ftui
+cp "$(cabal new-exec --verbose=0 --offline sh -- -c 'command -v ghcup')" .
+strip ./ghcup
+cp ghcup "./${ARTIFACT}"

CHANGELOG.md

@@ -1,5 +1,139 @@
 # Revision history for ghcup
 
+## 0.1.15 -- ????-??-??
+
+* Add windows support wrt [#130](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/130)
+* Add date to GHC bindist names created by ghcup
+* Warn when /tmp doesn't have 5GB or more of disk space
+* Allow to compile GHC from git repo wrt [#126](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/126)
+* Allow to set custom ghc version when running 'ghcup compile ghc' wrt [#136](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/136)
+* Add stack support
+
+## 0.1.14.2 -- 2021-05-12
+
+* Remove dead dependency on ascii-string
+
+## 0.1.14.1 -- 2021-04-11
+
+* Make internal symlink target parser more lax, fixes [#119](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/119)
+* Prepare for hackage release
+
+## 0.1.14 -- 2021-03-07
+
+* Major bugfix: fix handling of stray versions wrt [#116](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/116)
+* Fix error messages and overhaul pretty printing wrt [#115](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/115)
+
+## 0.1.13 -- 2021-02-26
+
+* Support ARMv7/AARCH64
+* Add command line completions for installed and available versions wrt [MR #70](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/70)
+* Allow to cycle through set tools wrt [#114](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/114)
+* Fix item selection with unavailable versions wrt [#107](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/107)
+* Allow for dynamic post-install, post-remove and pre-compile msgs wrt [MR #68](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/68)
+* Alert user if upgraded ghcup is shadowed by old ghcup wrt [#111](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/111)
+* Fix to `ghcup` directory creation and placement for the XDG install mode ([MR #49](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/49))
+* Do 755 permissions on executables, wrt #97
+* Add [NO_COLOR](https://no-color.org/) support wrt [MR #47](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/47)
+
+## 0.1.12 -- 2020-11-21
+
+* Fix disappearing HLS symlinks wrt #91
+* improve TUI:
+  - separators between tools sections
+  - reverse list order so latest is on top
+  - expand the blues selected bar
+  - show new latest versions in bright white
+* allow configuration file and setting TUI hotkeys wrt #41
+  - see https://gitlab.haskell.org/haskell/ghcup-hs#configuration for a more in-depth explanation
+* add a `--set` switch to `ghcup install ghc` to automatically set as default after install
+* emit warnings when CC/LD is set wrt #82
+* add support for version ranges in distro specifiers wrt #84
+  - e.g. `"(>= 19 && <= 20) || ==0.2.2"` is a valid version key for distro
+
+## 0.1.11 -- 2020-09-23
+
+* Add support for installing haskell-language-server, wrt #65
+* When compiling GHC from source create a bindist first, store that bindist in `~/.ghcup/cache` and install it, wrt #51
+* Allow to compile over existing version (`ghcup compile ghc -v 8.6.5 -b 8.6.5`) and replace it wrt #59
+* simplify installing from custom bindist wrt #60
+  - `ghcup install ghc -u <url> <version>`
+* fix bug when cabal isn't marked executable in bindist
+* fix bug when `~/.ghcup` is a valid symlink wrt #49
+* Drop support for compiling cabal from source (the old bootstrap script is discontinued)
+
+## 0.1.10 -- 2020-08-14
+
+* Show stray Cabals (useful for pre-releases or compiled ones)
+
+## 0.1.9 -- 2020-08-14
+
+* Fix bug when uninstalling all cabal versions
+* Fix bug when setting a non-installed ghc version as current default
+* Use yaml instead of generated json for download info for ease of adding new GHC versions #44
+* Allow pre-release versions of GHC/cabal
+* Add XDG dirs support (set `GHCUP_USE_XDG_DIRS`) wrt #39
+* Allow to specify regex for tarball subdir (e.g. `ghc-.*`)
+* Allow installing arbitrary bindists more seamlessly:
+  - e.g. installing GHC HEAD: `ghcup -n install ghc -u '{"dlHash": "", "dlSubdir": { "RegexDir": "ghc-.*"}, "dlUri": "https://gitlab.haskell.org/api/v4/projects/1/jobs/artifacts/master/raw/ghc-x86_64-fedora27-linux.tar.xz?job=validate-x86_64-linux-fedora27" }' head`
+* Avoid duplicate edits to .bashrc/.zshrc wrt #43
+
+## 0.1.8 -- 2020-07-21
+
+* Fix bug in logging thread dying on newlines
+* Allow to install from arbitrary bindists: `ghcup -n install ghc -u '{"dlHash": "", "dlSubdir": "ghc-8.10.1", "dlUri": "https://github.com/commercialhaskell/ghc/releases/download/ghc-8.10.1-release/ghc-8.10.1-x86_64-deb9-linux.tar.xz"}' 8.10.1`
+
+## 0.1.7 -- 2020-07-20
+
+* Fix a bug in libarchive not unpacking some uncleanly packed bindists
+* Improved fish support in bootstrap-haskell
+* Only check for upgrades when not upgrading
+* Fix platform detection for i386 docker images
+* Improve alpine support
+  - more/proper bindists
+  - don't fall back to glibc based bindists
+  - install bindists with `--disable-ld-override` to avoid ld.gold bugs
+
+## 0.1.6 -- 2020-07-13
+
+* Create a new curses (brick) based TUI, accessible via `ghcup tui` #24
+* Support multiple installed versions of cabal #23
+* Improvements to `ghcup list` (show unavailable bindists for platform)
+* Fix redhat downloads #29
+* Support for hadrian bindists (fixes alpine-8.10.1) #31
+* Add FreeBSD bindists 8.6.5 and 8.8.3
+* Fix memory leak during unpack
+
+## 0.1.5 -- 2020-04-30
+
+* Fix errors when PATH variable contains path components that are actually files
+* Add `--version` and `--numeric-version` options
+* Add `changelog` command
+* Also check for available GHC and Cabal updates on start
+* Add base versions as tags for every GHC version (these are "installable" tags and the latest GHC version matching the tag will be picked)
+* Added `--format-raw` to list subcommand
+* Allow to install X.Y versions (e.g.: ghcup install 8.8)
+* Implement `--keep=<always|errors|never>` to control temporary build directories cleanup
+* Add proper shell completions to the repo
+* Fix building of documentation
+* Allow to work in offline mode and use cached files if possible
+* Allow to set the downloader via `--downloader=<curl|wget>`
+* Support for compiling and installing a cross GHC (see README). This is experimental.
+
+## 0.1.4 -- 2020-04-16
+
+* build on all platforms with curl (as a binary), wrt https://gitlab.haskell.org/haskell/ghcup-hs/issues/6
+* Fix unlinking of ghc symlinks after new installation, wrt https://gitlab.haskell.org/haskell/ghcup-hs/issues/7
+
+## 0.1.3 -- 2020-04-15
+
+* Fix lesser bug when skipping ghcup update
+
+## 0.1.2 -- 2020-04-15
+
+* Fix bug when removing the set GHC version
+* Fix use of undocumented `GHCUP_INSTALL_BASE_PREFIX` variable
+* skip upgrade if ghcup is already latest version
+
 ## 0.1.1 -- 2020-04-15
 
 * fix awful fdopendir bug on mac bug by updating hpath-posix

Dockerfile

@@ -1,42 +0,0 @@
-FROM alpine:edge
-
-# ghc and cabal
-RUN apk add --no-cache \
-	curl \
-	gcc \
-	g++ \
-	gmp-dev \
-	ncurses-dev \
-	libffi-dev \
-	make \
-	xz \
-	tar \
-	perl \
-	\
-	cabal \
-	ghc
-
-# utils
-RUN apk add --no-cache \
-	bash
-
-## Package specific
-RUN apk add --no-cache \
-	zlib \
-	zlib-dev \
-	zlib-static \
-	gmp \
-	gmp-dev \
-	openssl-dev \
-	openssl-libs-static \
-	xz \
-	xz-dev
-
-RUN cabal v2-update
-
-COPY . /app
-
-WORKDIR /app
-
-RUN chmod +x /app/docker/build.sh
-

HACKING.md

@@ -6,10 +6,6 @@
 
 This is an open variant, similar to [plucky](https://hackage.haskell.org/package/plucky) or [oops](https://github.com/i-am-tom/oops) and allows us to combine different error types. Maybe it is too much and it's a little bit [unergonomic](https://github.com/haskus/packages/issues/32) at times. If it really hurts maintenance, it will be removed. It was more of an experiment.
 
-### No use of filepath or directory
-
-Filepath and directory have two fundamental problems: 1. they use String as filepath (see [AFPP](https://gitlab.haskell.org/ghc/ghc/-/wikis/proposal/abstract-file-path) as to why this is wrong) and 2. they try very hard to be cross-platform at the expense of low-level correctness. Instead, we use the [hpath](https://github.com/hasufell/hpath) libraries for file and filepath related stuff, which also gives us stronger filepath types.
-
 ### No use of haskell-TLS
 
 I consider haskell-TLS an interesting experiment, but not a battle-tested and peer-reviewed crypto implementation. There is little to no research about what the intricacies of using haskell for low-level crypto are and how vulnerable such binaries are. Instead, we use either curl the binary (for FreeBSD and mac) or http-io-streams, which works with OpenSSL bindings.
@@ -43,3 +39,33 @@ Kazu Yamamoto [explained it in his PR](https://github.com/yesodweb/wai/pull/752#
 1. Brittany
 2. mtl-style preferred
 3. no overly pointfree style
+
+## Code structure
+
+Main functionality is in `GHCup` module. Utility functions are
+organised tree-ish in `GHCup.Utils` and `GHCup.Utils.*`.
+
+Anything dealing with ghcup specific directories is in
+`GHCup.Utils.Dirs`.
+
+Download information on where to fetch bindists from is in the appropriate
+yaml files: `ghcup-<yaml-ver>.yaml`.
+
+## Common Tasks
+
+### Adding a new GHC version
+
+1. open the latest `ghcup-<yaml-ver>.yaml`
+2. find the latest ghc version (in yaml tree e.g. `ghcupDownloads -> GHC -> 8.10.3`)
+3. copy-paste it
+4. adjust the version, tags, changelog, source url
+5. adjust the various bindist urls (make sure to also change the yaml anchors)
+6. run `cabal run exe:ghcup-gen -- check-tarballs -f ghcup-<yaml-ver>.yaml -u 'ghc-8\.10\.4'`
+
+## Major refactors
+
+1. First major refactor included adding cross support. This added
+   `GHCTargetVersion`, which includes the target in addition to the version.
+   Most of the `Version` parameters to functions had to be replaced with
+   that and ensured the logic is consistent for cross and non-cross
+   installs.

README.md

@@ -4,13 +4,20 @@ It follows the unix UNIX philosophy of [do one thing and do it well](https://en.
 
 Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [pyenv](https://github.com/pyenv/pyenv) and [jenv](http://www.jenv.be).
 
-*Ubuntu users may prefer [hvr's ppa](https://launchpad.net/~hvr/+archive/ubuntu/ghc).*
-
 ## Table of Contents
 
    * [Installation](#installation)
+     * [Simple bootstrap](#simple-bootstrap)
+     * [Manual install](#manual-install)
+     * [Vim integration](#vim-integration)
    * [Usage](#usage)
+     * [Configuration](#configuration)
      * [Manpages](#manpages)
+     * [Shell-completion](#shell-completion)
+     * [Cross support](#cross-support)
+     * [XDG support](#xdg-support)
+     * [Env variables](#env-variables)
+     * [Installing custom bindists](#installing-custom-bindists)
    * [Design goals](#design-goals)
    * [How](#how)
    * [Known users](#known-users)
@@ -34,40 +41,115 @@ Then adjust your `PATH` in `~/.bashrc` (or similar, depending on your shell) lik
 export PATH="$HOME/.cabal/bin:$HOME/.ghcup/bin:$PATH"
 ```
 
+### Vim integration
+
+See [ghcup.vim](https://github.com/hasufell/ghcup.vim).
+
 ## Usage
 
 See `ghcup --help`.
 
-Common use cases are:
+For the simple interactive TUI, run:
+
+```sh
+ghcup tui
+```
+
+For the full functionality via cli:
 
 ```sh
 # list available ghc/cabal versions
 ghcup list
 
 # install the recommended GHC version
-ghcup install
+ghcup install ghc
 
 # install a specific GHC version
-ghcup install 8.2.2
+ghcup install ghc 8.2.2
 
 # set the currently "active" GHC version
-ghcup set 8.4.4
+ghcup set ghc 8.4.4
 
 # install cabal-install
-ghcup install-cabal
+ghcup install cabal
 
 # update ghcup itself
 ghcup upgrade
 ```
 
-Generally this is meant to be used with [`cabal-install`](https://hackage.haskell.org/package/cabal-install), which
+GHCup works very well with [`cabal-install`](https://hackage.haskell.org/package/cabal-install), which
 handles your haskell packages and can demand that [a specific version](https://cabal.readthedocs.io/en/latest/nix-local-build.html#cfg-flag---with-compiler)  of `ghc` is available, which `ghcup` can do.
 
+### 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).
+
+Partial configuration is fine. Command line options always overwrite the config file settings.
+
 ### 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.
 `MANPATH` may be required to be unset.
 
+### Shell-completion
+
+Shell completions are in `shell-completions`.
+
+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
+
+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
+libraries installed for the target platform.
+
+Consult the GHC documentation on the [prerequisites](https://gitlab.haskell.org/ghc/ghc/-/wikis/building/cross-compiling#tools-to-install).
+For distributions with non-standard locations of cross toolchain and
+libraries, this may need some tweaking of `build.mk` or configure args.
+See `ghcup compile ghc --help` for further information.
+
+### XDG support
+
+To enable XDG style directories, set the environment variable `GHCUP_USE_XDG_DIRS` to anything.
+
+Then you can control the locations via XDG environment variables as such:
+
+* `XDG_DATA_HOME`: GHCs will be unpacked in `ghcup/ghc` subdir (default: `~/.local/share`)
+* `XDG_CACHE_HOME`: logs and download files will be stored in `ghcup` subdir (default: `~/.cache`)
+* `XDG_BIN_HOME`: binaries end up here (default: `~/.local/bin`)
+* `XDG_CONFIG_HOME`: the config file is stored in `ghcup` subdir as `config.yaml` (default: `~/.config`)
+
+### Env variables
+
+This is the complete list of env variables that change GHCup behavior:
+
+* `GHCUP_USE_XDG_DIRS`: see [XDG support](#xdg-support) above
+* `TMPDIR`: where ghcup does the work (unpacking, building, ...)
+* `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
+* `CC`/`LD` etc.: full environment is passed to the build system when compiling GHC via GHCup
+
+### Installing custom bindists
+
+There are a couple of good use cases to install custom bindists:
+
+1. manually built bindists (e.g. with patches)
+  - example: `ghcup install ghc -u 'file:///home/mearwald/tmp/ghc-eff-patches/ghc-8.10.2-x86_64-deb10-linux.tar.xz' 8.10.2-eff`
+2. GHC head CI bindists
+  - example: `ghcup install ghc -u 'https://gitlab.haskell.org/api/v4/projects/1/jobs/artifacts/master/raw/ghc-x86_64-fedora27-linux.tar.xz?job=validate-x86_64-linux-fedora27' head`
+3. DWARF bindists
+  - example: `ghcup install ghc -u 'https://downloads.haskell.org/~ghc/8.10.2/ghc-8.10.2-x86_64-deb10-linux-dwarf.tar.xz' 8.10.2-dwarf`
+
+Since the version parser is pretty lax, `8.10.2-eff` and `head` are both valid versions
+and produce the binaries `ghc-8.10.2-eff` and `ghc-head` respectively.
+GHCup always needs to know which version the bindist corresponds to (this is not automatically
+detected).
+
 ## Design goals
 
 1. simplicity
@@ -96,10 +178,22 @@ In addition this script can also install `cabal-install`.
 
 ## Known users
 
+* Github action [haskell/actions/setup](https://github.com/haskell/actions/tree/main/setup)
 * [vabal](https://github.com/Franciman/vabal)
 
 ## Known problems
 
+### Custom ghc version names
+
+When installing ghc bindists with custom version names as outlined in
+[installing custom bindists](#installing-custom-bindists), then cabal might
+be unable to find the correct `ghc-pkg` (also see [#73](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/73))
+if you use `cabal build --with-compiler=ghc-foo`. Instead, point it to the full path, such as:
+`cabal build --with-compiler=$HOME/.ghcup/ghc/<version-name>/bin/ghc` or set that GHC version
+as the current one via: `ghcup set ghc <version-name>`.
+
+This problem doesn't exist for regularly installed GHC versions.
+
 ### Limited distributions supported
 
 Currently only GNU/Linux distributions compatible with the [upstream GHC](https://www.haskell.org/ghc/download_ghc_8_6_1.html#binaries) binaries are supported.
@@ -140,5 +234,8 @@ ghcup is not a reimplementation of stack. The only common part is automatic inst
 
 2. Why not support windows?
 
-Consider using [Chocolatey](https://chocolatey.org/search?q=ghc) or [ghcups](https://github.com/kakkun61/ghcups).
+We do.
 
+3. Why the haskell reimplementation?
+
+:-)

RELEASING.md

@@ -1,11 +1,19 @@
 # RELEASING
 
-1. update `GHCup.Version` module. `ghcupURL` must only be updated if we change the `_toolRequirements` type or the JSON representation of it. The version of the json represents the change increments. `ghcUpVer` is the current application version.
+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. Add/fix downloads to `GHCupDownloads` module, then run `ghcup-gen gen` to generate the new json and validate it via `ghcup-gen check`.
+2. Update version in ghcup.cabal
 
-3. Commit and git push with tag. Wait for tests to succeed.
+3. Add ChangeLog entry
 
-4. Upload the new `ghcup-<ver>.json` to `webhost.haskell.org/ghcup/data/`.
+4. Add/fix downloads in `ghcup-<ver>.yaml`, then verify with `ghcup-gen check -f ghcup-<ver>.yaml`
 
-5. Build ghcup releases for Linux (fully static), mac (with `-fcurl`) and FreeBSD (with `-fcurl`). Upload to `webhost.haskell.org/ghcup/bin/` and update symlinks.
+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`

TODO.md

@@ -2,30 +2,38 @@
 
 ## Now
 
-* ghcup migration
-* update static links
+* ghcup init?
+* merge two download files
+* fetch/unpack functionality
+* installing multiple versions of the same
+* post-install
 
-* releases, update download info and bootstrap-haskell
+* proper test suite
+
+* !! update of 0.1.5 must go in ghcup-0.0.1.json !!
+
+* try to run exe before upgrade (backup to ~/.ghcup/bin/ghcup.old)
+* stdout flushing?
+* resume support (for make-install only)
 
 ## Maybe
 
-* maybe: changelog          Show the changelog of a GHC release (online)
+* version ranges in json
 * sign the JSON? (Or check gpg keys?)
 * testing (especially distro detection -> unit tests)
 
 ## Later
 
-* i386 support
 * add support for RC/alpha/HEAD versions
 
 ## Cleanups
 
-* too many decodeutf8
 * avoid alternative for IO
 * use plucky or oops instead of Excepts
 
 ## Questions
 
+* move out GHCup.Version module, bc it's not library-ish?
 * mirror support
 * interactive handling when distro doesn't exist and we know the tarball is incompatible?
 * ghcup-with wrapper to execute a command with a given ghc in PATH?

app/ghcup-gen/GHCupInfo.hs

@@ -1,11 +0,0 @@
-module GHCupInfo where
-
-import           GHCupDownloads
-import           ToolRequirements
-import           GHCup.Types
-
-
-ghcupInfo :: GHCupInfo
-ghcupInfo = GHCupInfo { _toolRequirements = toolRequirements
-                      , _ghcupDownloads   = ghcupDownloads
-                      }

app/ghcup-gen/Main.hs

@@ -13,10 +13,8 @@ module Main where
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.Logger
-import           GHCupInfo
 
-import           Data.Aeson                     ( eitherDecode, encode )
-import           Data.Aeson.Encode.Pretty
+import           Data.Char                      ( toLower )
 #if !MIN_VERSION_base(4,13,0)
 import           Data.Semigroup                 ( (<>) )
 #endif
@@ -24,51 +22,19 @@ import           Options.Applicative     hiding ( style )
 import           System.Console.Pretty
 import           System.Exit
 import           System.IO                      ( stdout )
+import           Text.Regex.Posix
 import           Validate
 
 import qualified Data.ByteString               as B
-import qualified Data.ByteString.Lazy          as L
+import qualified Data.Yaml                     as Y
 
 
 data Options = Options
   { optCommand :: Command
   }
 
-data Command = GenJSON GenJSONOpts
-             | ValidateJSON ValidateJSONOpts
-             | ValidateTarballs ValidateJSONOpts
-
-data Output
-  = FileOutput FilePath -- optsparse-applicative doesn't handle ByteString correctly anyway
-  | StdOutput
-
-fileOutput :: Parser Output
-fileOutput =
-  FileOutput
-    <$> (strOption
-          (long "file" <> short 'f' <> metavar "FILENAME" <> help
-            "Output to a file"
-          )
-        )
-
-stdOutput :: Parser Output
-stdOutput = flag'
-  StdOutput
-  (short 'o' <> long "stdout" <> help "Print to stdout (default)")
-
-outputP :: Parser Output
-outputP = fileOutput <|> stdOutput
-
-
-data GenJSONOpts = GenJSONOpts
-  { output :: Maybe Output
-  , pretty :: Bool
-  }
-
-genJSONOpts :: Parser GenJSONOpts
-genJSONOpts = GenJSONOpts <$> optional outputP <*> switch
-  (short 'p' <> long "pretty" <> help "Make JSON output pretty (human readable)"
-  )
+data Command = ValidateYAML ValidateYAMLOpts
+             | ValidateTarballs ValidateYAMLOpts TarballFilter
 
 
 data Input
@@ -78,11 +44,10 @@ data Input
 fileInput :: Parser Input
 fileInput =
   FileInput
-    <$> (strOption
+    <$> strOption
           (long "file" <> short 'f' <> metavar "FILENAME" <> help
             "Input file to validate"
           )
-        )
 
 stdInput :: Parser Input
 stdInput = flag'
@@ -92,82 +57,74 @@ stdInput = flag'
 inputP :: Parser Input
 inputP = fileInput <|> stdInput
 
-data ValidateJSONOpts = ValidateJSONOpts
-  { input :: Maybe Input
+data ValidateYAMLOpts = ValidateYAMLOpts
+  { vInput :: Maybe Input
   }
 
-validateJSONOpts :: Parser ValidateJSONOpts
-validateJSONOpts = ValidateJSONOpts <$> optional inputP
+validateYAMLOpts :: Parser ValidateYAMLOpts
+validateYAMLOpts = ValidateYAMLOpts <$> optional inputP
+
+tarballFilterP :: Parser TarballFilter
+tarballFilterP = option readm $
+  long "tarball-filter" <> short 'u' <> metavar "<tool>-<version>" <> value def
+    <> help "Only check certain tarballs (format: <tool>-<version>)"
+  where
+    def = TarballFilter Nothing (makeRegex ("" :: String))
+    readm = do
+      s <- str
+      case span (/= '-') s of
+        (_, []) -> fail "invalid format, missing '-' after the tool name"
+        (t, v) | [tool] <- [ tool | tool <- [minBound..maxBound], low (show tool) == low t ] ->
+          pure (TarballFilter $ Just tool) <*> makeRegexOptsM compIgnoreCase execBlank (drop 1 v)
+        _ -> fail "invalid tool"
+    low = fmap toLower
+
 
 opts :: Parser Options
 opts = Options <$> com
 
 com :: Parser Command
 com = subparser
-  (  (command
-       "gen"
-       (   GenJSON
-       <$> (info (genJSONOpts <**> helper)
-                 (progDesc "Generate the json downloads file")
-           )
-       )
-     )
-  <> (command
+  (  command
        "check"
-       (   ValidateJSON
-       <$> (info (validateJSONOpts <**> helper)
-                 (progDesc "Validate the JSON")
-           )
+       (   ValidateYAML
+       <$> info (validateYAMLOpts <**> helper)
+                (progDesc "Validate the YAML")
        )
-     )
-  <> (command
+  <> command
        "check-tarballs"
-       (   ValidateTarballs
-       <$> (info
-             (validateJSONOpts <**> helper)
-             (progDesc "Validate all tarballs (download and checksum)")
-           )
+       (info
+         ((ValidateTarballs <$> validateYAMLOpts <*> tarballFilterP) <**> helper)
+         (progDesc "Validate all tarballs (download and checksum)")
        )
-     )
   )
 
 
 
 main :: IO ()
 main = do
-  customExecParser (prefs showHelpOnError) (info (opts <**> helper) idm)
+  _ <- customExecParser (prefs showHelpOnError) (info (opts <**> helper) idm)
     >>= \Options {..} -> case optCommand of
-          GenJSON gopts -> do
-            let bs True =
-                  encodePretty' (defConfig { confIndent = Spaces 2 }) ghcupInfo
-                bs False = encode ghcupInfo
-            case gopts of
-              GenJSONOpts { output = Nothing, pretty } ->
-                L.hPutStr stdout (bs pretty)
-              GenJSONOpts { output = Just StdOutput, pretty } ->
-                L.hPutStr stdout (bs pretty)
-              GenJSONOpts { output = Just (FileOutput file), pretty } ->
-                L.writeFile file (bs pretty)
-          ValidateJSON vopts -> case vopts of
-            ValidateJSONOpts { input = Nothing } ->
-              L.getContents >>= valAndExit validate
-            ValidateJSONOpts { input = Just StdInput } ->
-              L.getContents >>= valAndExit validate
-            ValidateJSONOpts { input = Just (FileInput file) } ->
-              L.readFile file >>= valAndExit validate
-          ValidateTarballs vopts -> case vopts of
-            ValidateJSONOpts { input = Nothing } ->
-              L.getContents >>= valAndExit validateTarballs
-            ValidateJSONOpts { input = Just StdInput } ->
-              L.getContents >>= valAndExit validateTarballs
-            ValidateJSONOpts { input = Just (FileInput file) } ->
-              L.readFile file >>= valAndExit validateTarballs
+          ValidateYAML vopts -> case vopts of
+            ValidateYAMLOpts { vInput = Nothing } ->
+              B.getContents >>= valAndExit validate
+            ValidateYAMLOpts { vInput = Just StdInput } ->
+              B.getContents >>= valAndExit validate
+            ValidateYAMLOpts { vInput = Just (FileInput file) } ->
+              B.readFile file >>= valAndExit validate
+          ValidateTarballs vopts tarballFilter -> case vopts of
+            ValidateYAMLOpts { vInput = Nothing } ->
+              B.getContents >>= valAndExit (validateTarballs tarballFilter)
+            ValidateYAMLOpts { vInput = Just StdInput } ->
+              B.getContents >>= valAndExit (validateTarballs tarballFilter)
+            ValidateYAMLOpts { vInput = Just (FileInput file) } ->
+              B.readFile file >>= valAndExit (validateTarballs tarballFilter)
   pure ()
 
  where
   valAndExit f contents = do
-    (GHCupInfo _ av) <- case eitherDecode contents of
+    (GHCupInfo _ av gt) <- case Y.decodeEither' contents of
       Right r -> pure r
       Left  e -> die (color Red $ show e)
-    myLoggerT (LoggerConfig True (B.hPut stdout) (\_ -> pure ())) (f av)
+    myLoggerT (LoggerConfig True (B.hPut stdout) (\_ -> pure ())) (f av gt)
       >>= exitWith

app/ghcup-gen/ToolRequirements.hs

@@ -1,94 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes       #-}
-
-module ToolRequirements where
-
-import           GHCup.Types
-import           GHCup.Utils.String.QQ
-
-import qualified Data.Map                      as M
-
-
-
--- | Currently 'GHC' is used for both GHC and cabal to simplify
--- this, until we need actual separation.
-toolRequirements :: ToolRequirements
-toolRequirements = M.fromList
-  [ ( GHC
-    , M.fromList
-      [ ( Nothing
-        , M.fromList
-          [ ( Linux UnknownLinux
-            , M.fromList
-              [ ( Nothing
-                , Requirements
-                  []
-                  [s|You need the following packages: curl g++ gcc gmp make ncurses realpath xz-utils. Consult your distro documentation on the exact names of those packages.|]
-                )
-              ]
-            )
-          , ( Linux Alpine
-            , M.fromList
-              [ ( Nothing
-                , Requirements
-                  [ "curl"
-                  , "gcc"
-                  , "g++"
-                  , "gmp-dev"
-                  , "ncurses-dev"
-                  , "libffi-dev"
-                  , "make"
-                  , "xz"
-                  , "tar"
-                  , "perl"
-                  ]
-                  ""
-                )
-              ]
-            )
-          , ( Linux Ubuntu
-            , M.fromList
-              [ ( Nothing
-                , Requirements
-                  [ "build-essential"
-                  , "curl"
-                  , "libgmp-dev"
-                  , "libffi-dev"
-                  , "libncurses-dev"
-                  , "libtinfo5"
-                  ]
-                  ""
-                )
-              ]
-            )
-          , ( Darwin
-            , M.fromList
-              [ ( Nothing
-                , Requirements
-                  []
-                  "On OS X, in the course of running ghcup you will be given a dialog box to install the command line tools. Accept and the requirements will be installed for you. You will then need to run the command again."
-                )
-              ]
-            )
-          , ( FreeBSD
-            , M.fromList
-              [ ( Nothing
-                , Requirements
-                  [ "curl"
-                  , "gcc"
-                  , "gmp"
-                  , "gmake"
-                  , "ncurses"
-                  , "perl5"
-                  , "libffi"
-                  , "libiconv"
-                  ]
-                  ""
-                )
-              ]
-            )
-          ]
-        )
-      ]
-    )
-  ]

app/ghcup-gen/Validate.hs

@@ -1,14 +1,29 @@
-{-# LANGUAGE TemplateHaskell  #-}
+{-# LANGUAGE CPP              #-}
+{-# LANGUAGE DataKinds        #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE QuasiQuotes      #-}
+{-# LANGUAGE TemplateHaskell  #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ViewPatterns     #-}
 
 module Validate where
 
 import           GHCup
 import           GHCup.Download
+import           GHCup.Errors
+import           GHCup.Platform
 import           GHCup.Types
+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
@@ -19,17 +34,24 @@ import           Control.Monad.Trans.Reader     ( runReaderT )
 import           Control.Monad.Trans.Resource   ( runResourceT
                                                 , MonadUnliftIO
                                                 )
+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
 
 
 data ValidationError = InternalError String
@@ -46,11 +68,12 @@ addError = do
 
 validate :: (Monad m, MonadLogger m, MonadThrow m, MonadIO m, MonadUnliftIO m)
          => GHCupDownloads
+         -> M.Map GlobalTool DownloadInfo
          -> m ExitCode
-validate dls = do
+validate dls _ = do
   ref <- liftIO $ newIORef 0
 
-  -- * verify binary downloads * --
+  -- verify binary downloads --
   flip runReaderT ref $ do
     -- unique tags
     forM_ (M.toList dls) $ \(t, _) -> checkUniqueTags t
@@ -59,10 +82,11 @@ validate dls = do
     forM_ (M.toList dls) $ \(t, versions) ->
       forM_ (M.toList versions) $ \(v, vi) ->
         forM_ (M.toList $ _viArch vi) $ \(arch, pspecs) -> do
-          checkHasRequiredPlatforms t v arch (M.keys pspecs)
+          checkHasRequiredPlatforms t v (_viTags vi) arch (M.keys pspecs)
 
-    checkGHCisSemver
+    checkGHCVerIsValid
     forM_ (M.toList dls) $ \(t, _) -> checkMandatoryTags t
+    _ <- checkGHCHasBaseVersion
 
     -- exit
     e <- liftIO $ readIORef ref
@@ -72,20 +96,37 @@ validate dls = do
         lift $ $(logInfo) [i|All good|]
         pure ExitSuccess
  where
-  checkHasRequiredPlatforms t v arch pspecs = do
+  checkHasRequiredPlatforms t v tags arch pspecs = do
     let v' = prettyVer v
-    when (not $ any (== Linux UnknownLinux) pspecs) $ do
+        arch' = prettyShow arch
+    when (notElem (Linux UnknownLinux) pspecs) $ do
       lift $ $(logError)
-        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch}|]
+        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch'}|]
       addError
-    when ((not $ any (== Darwin) pspecs) && arch == A_64) $ do
-      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch}|]
+    when ((notElem Darwin pspecs) && arch == A_64) $ do
+      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch'}|]
       addError
-    when ((not $ any (== FreeBSD) pspecs) && arch == A_64) $ lift $ $(logWarn)
-      [i|FreeBSD missing for #{t} #{v'} #{arch}|]
+    when ((notElem FreeBSD pspecs) && arch == A_64) $ lift $ $(logWarn)
+      [i|FreeBSD missing for #{t} #{v'} #{arch'}|]
+    when (notElem Windows pspecs && arch == A_64) $ do
+      lift $ $(logError)
+        [i|Windows missing for for #{t} #{v'} #{arch'}|]
+      addError
+
+    -- alpine needs to be set explicitly, because
+    -- we cannot assume that "Linux UnknownLinux" runs on Alpine
+    -- (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
+        Cabal | v > [vver|2.4.1.0|]
+              , arch `elem` [A_64, A_32] -> lift ($(logError) [i|Linux Alpine missing for #{t} #{v'} #{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'}|])
+        _ -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]
 
   checkUniqueTags tool = do
-    let allTags = join $ fmap snd $ availableToolVersions dls tool
+    let allTags = join $ M.elems $ availableToolVersions dls tool
     let nonUnique =
           fmap fst
             .   filter (\(_, b) -> not b)
@@ -93,7 +134,7 @@ validate dls = do
                     (\case
                       [] -> throwM $ InternalError "empty inner list"
                       (t : ts) ->
-                        pure $ (t, ) $ if isUniqueTag t then ts == [] else True
+                        pure $ (t, ) (not (isUniqueTag t) || null ts)
                     )
                 . group
                 . sort
@@ -105,26 +146,47 @@ validate dls = do
         lift $ $(logError) [i|Tags not unique for #{tool}: #{xs}|]
         addError
    where
-    isUniqueTag Latest      = True
-    isUniqueTag Recommended = True
+    isUniqueTag Latest         = True
+    isUniqueTag Recommended    = True
+    isUniqueTag Old            = False
+    isUniqueTag Prerelease     = False
+    isUniqueTag (Base       _) = False
+    isUniqueTag (UnknownTag _) = False
 
-  checkGHCisSemver = do
+  checkGHCVerIsValid = do
     let ghcVers = toListOf (ix GHC % to M.keys % folded) dls
-    forM_ ghcVers $ \v -> case semver (prettyVer v) of
-      Left _ -> do
-        lift $ $(logError) [i|GHC version #{v} is not valid semver|]
-        addError
-      Right _ -> pure ()
+    forM_ ghcVers $ \v ->
+      case [ x | (x,"") <- readP_to_S V.parseVersion (T.unpack . prettyVer $ v) ] of
+        [_] -> pure ()
+        _   -> do
+          lift $ $(logError) [i|GHC version #{v} is not valid |]
+          addError
 
   -- a tool must have at least one of each mandatory tags
   checkMandatoryTags tool = do
-    let allTags = join $ fmap snd $ availableToolVersions dls tool
+    let allTags = join $ M.elems $ availableToolVersions dls tool
     forM_ [Latest, Recommended] $ \t -> case elem t allTags of
       False -> do
         lift $ $(logError) [i|Tag #{t} missing from #{tool}|]
         addError
       True -> pure ()
 
+  -- all GHC versions must have a base tag
+  checkGHCHasBaseVersion = do
+    let allTags = M.toList $ availableToolVersions dls GHC
+    forM allTags $ \(ver, tags) -> case any isBase tags of
+      False -> do
+        lift $ $(logError) [i|Base tag missing from GHC ver #{ver}|]
+        addError
+      True -> pure ()
+
+  isBase (Base _) = True
+  isBase _        = False
+
+data TarballFilter = TarballFilter
+  { tfTool    :: Maybe Tool
+  , tfVersion :: Regex
+  }
 
 validateTarballs :: ( Monad m
                     , MonadLogger m
@@ -132,24 +194,24 @@ validateTarballs :: ( Monad m
                     , MonadIO m
                     , MonadUnliftIO m
                     , MonadMask m
+                    , Alternative m
+                    , MonadFail m
                     )
-                 => GHCupDownloads
+                 => TarballFilter
+                 -> GHCupDownloads
+                 -> M.Map GlobalTool DownloadInfo
                  -> m ExitCode
-validateTarballs dls = do
+validateTarballs (TarballFilter tool versionRegex) dls gt = do
   ref <- liftIO $ newIORef 0
 
   flip runReaderT ref $ do
-     -- download/verify all binary tarballs
-    let
-      dlbis = nub $ join $ (M.elems dls) <&> \versions ->
-        join $ (M.elems versions) <&> \vi ->
-          join $ (M.elems $ _viArch vi) <&> \pspecs ->
-            join $ (M.elems pspecs) <&> \pverspecs -> (M.elems pverspecs)
-    forM_ dlbis $ downloadAll
+     -- download/verify all tarballs
+    let dlis = nubOrd $ dls ^.. each %& indices (maybe (const True) (==) tool) %> each %& indices (matchTest versionRegex . T.unpack . prettyVer) % (viSourceDL % _Just `summing` viArch % each % each % each)
+    when (null dlis) $ $(logError) [i|no tarballs selected by filter|] *> addError
 
-    let dlsrc = nub $ join $ (M.elems dls) <&> \versions ->
-          join $ (M.elems versions) <&> maybe [] (: []) . _viSourceDL
-    forM_ dlsrc $ downloadAll
+    let gdlis = nubOrd $ gt ^.. each
+
+    forM_ (dlis ++ gdlis) downloadAll
 
     -- exit
     e <- liftIO $ readIORef ref
@@ -160,22 +222,74 @@ validateTarballs dls = do
         pure ExitSuccess
 
  where
+  runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
+                                     , colorOutter  = B.hPut stderr
+                                     , rawOutter    = \_ -> pure ()
+                                     }
   downloadAll dli = do
-    let settings = Settings True False
-    let runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
-                                           , colorOutter  = B.hPut stderr
-                                           , rawOutter    = (\_ -> pure ())
-                                           }
+    dirs <- liftIO getDirs
+
+    pfreq <- (
+      runLogger . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound] . liftE $ platformRequest
+      ) >>= \case
+              VRight r -> pure r
+              VLeft e -> do
+                lift $ runLogger
+                  ($(logError) $ T.pack $ prettyShow e)
+                liftIO $ exitWith (ExitFailure 2)
+
+    let appstate = AppState (Settings True False Never Curl False GHCupURL) dirs defaultKeyBindings (GHCupInfo mempty mempty mempty) pfreq
 
     r <-
       runLogger
-      . flip runReaderT settings
+      . flip runReaderT appstate
       . runResourceT
-      . runE
-      $ downloadCached dli Nothing
+      . runE @'[DigestError
+               , DownloadFailed
+               , UnknownArchive
+#if defined(TAR)
+               , Tar.FormatError
+#else
+               , ArchiveResult
+#endif
+               ]
+      $ do
+        case tool of
+          Just GHCup -> do
+            let fn = "ghcup"
+            p <- liftE $ download (settings appstate) dli (cacheDir dirs) (Just fn)
+            liftE $ checkDigest (settings appstate) dli p
+            pure Nothing
+          _ -> do
+            p <- liftE $ downloadCached (settings appstate) dirs dli Nothing
+            fmap (Just . head . splitDirectories . head)
+              . liftE
+              . getArchiveFiles
+              $ p
     case r of
-      VRight _ -> pure ()
+      VRight (Just basePath) -> do
+        case _dlSubdir dli of
+          Just (RealDir prel) -> do
+            lift $ $(logInfo)
+              [i|verifying subdir: #{prel}|]
+            when (basePath /= prel) $ do
+              lift $ $(logError)
+                [i|Subdir doesn't match: expected "#{prel}", got "#{basePath}"|]
+              addError
+          Just (RegexDir regexString) -> do
+            lift $ $(logInfo)
+              [i|verifying subdir (regex): #{regexString}|]
+            let regex = makeRegexOpts
+                  compIgnoreCase
+                  execBlank
+                  regexString
+            when (not (match regex basePath)) $ do
+              lift $ $(logError)
+                [i|Subdir doesn't match: expected regex "#{regexString}", got "#{basePath}"|]
+              addError
+          Nothing -> pure ()
+      VRight Nothing -> pure ()
       VLeft  e -> do
         lift $ $(logError)
-          [i|Could not download (or verify hash) of #{dli}, Error was: #{e}|]
+          [i|Could not download (or verify hash) of #{dli}, Error was: #{prettyShow e}|]
         addError

app/ghcup/BrickMain.hs

@@ -0,0 +1,643 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE ViewPatterns      #-}
+{-# LANGUAGE RankNTypes        #-}
+
+module BrickMain where
+
+import           GHCup
+import           GHCup.Download
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Utils
+import           GHCup.Utils.Prelude ( decUTF8Safe )
+import           GHCup.Utils.File
+import           GHCup.Utils.Logger
+
+import           Brick
+import           Brick.Widgets.Border
+import           Brick.Widgets.Border.Style
+import           Brick.Widgets.Center
+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
+import           Data.Bool
+import           Data.Functor
+import           Data.List
+import           Data.Maybe
+import           Data.IORef
+import           Data.String.Interpolate
+import           Data.Vector                    ( Vector
+                                                , (!?)
+                                                )
+import           Data.Versions           hiding ( str )
+import           Haskus.Utils.Variant.Excepts
+import           Prelude                 hiding ( appendFile )
+import           System.Environment
+import           System.Exit
+import           System.IO.Unsafe
+import           Text.PrettyPrint.HughesPJClass ( prettyShow )
+import           URI.ByteString
+
+import qualified GHCup.Types                   as GT
+
+import qualified Data.Text                     as T
+import qualified Graphics.Vty                  as Vty
+import qualified Data.Vector                   as V
+
+
+hiddenTools :: [Tool]
+hiddenTools = [Stack]
+
+
+data BrickData = BrickData
+  { lr    :: [ListResult]
+  }
+  deriving Show
+
+data BrickSettings = BrickSettings
+  { showAllVersions :: Bool
+  , showAllTools    :: Bool
+  }
+  deriving Show
+
+data BrickInternalState = BrickInternalState
+  { clr :: Vector ListResult
+  , ix  :: Int
+  }
+  deriving Show
+
+data BrickState = BrickState
+  { appData     :: BrickData
+  , appSettings :: BrickSettings
+  , appState    :: BrickInternalState
+  , appKeys     :: KeyBindings
+  }
+  deriving Show
+
+
+keyHandlers :: KeyBindings
+            -> [ ( Vty.Key
+                 , BrickSettings -> String
+                 , BrickState -> EventM n (Next BrickState)
+                 )
+               ]
+keyHandlers KeyBindings {..} =
+  [ (bQuit, const "Quit"     , halt)
+  , (bInstall, const "Install"  , withIOAction install')
+  , (bUninstall, const "Uninstall", withIOAction del')
+  , (bSet, const "Set"      , withIOAction ((liftIO .) . set'))
+  , (bChangelog, const "ChangeLog", withIOAction changelog')
+  , ( bShowAllVersions
+    , \BrickSettings {..} ->
+       if showAllVersions then "Don't show all versions" else "Show all versions"
+    , hideShowHandler (not . showAllVersions) showAllTools
+    )
+  , ( bShowAllTools
+    , \BrickSettings {..} ->
+       if showAllTools then "Don't show all tools" else "Show all tools"
+    , hideShowHandler showAllVersions (not . showAllTools)
+    )
+  , (bUp, const "Up", \BrickState {..} -> continue BrickState{ appState = moveCursor 1 appState Up, .. })
+  , (bDown, const "Down", \BrickState {..} -> continue BrickState{ appState = moveCursor 1 appState Down, .. })
+  ]
+ where
+  hideShowHandler f p BrickState{..} =
+    let newAppSettings   = appSettings { showAllVersions = f appSettings , showAllTools = p appSettings }
+        newInternalState = constructList appData newAppSettings (Just appState)
+    in  continue (BrickState appData newAppSettings newInternalState appKeys)
+
+
+showKey :: Vty.Key -> String
+showKey (Vty.KChar c) = [c]
+showKey Vty.KUp = "↑"
+showKey Vty.KDown = "↓"
+showKey key = tail (show key)
+
+
+ui :: AttrMap -> BrickState -> Widget String
+ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
+  = padBottom Max
+      ( withBorderStyle unicode
+        $ borderWithLabel (str "GHCup")
+          (center (header <=> hBorder <=> renderList' appState))
+      )
+    <=> footer
+
+ where
+  footer =
+    withAttr "help"
+      . txtWrap
+      . T.pack
+      . foldr1 (\x y -> x <> "  " <> y)
+      . fmap (\(key, s, _) -> showKey key <> ":" <> s as)
+      $ keyHandlers appKeys
+  header =
+    minHSize 2 emptyWidget
+      <+> padLeft (Pad 2) (minHSize 6 $ str "Tool")
+      <+> minHSize 15 (str "Version")
+      <+> padLeft (Pad 1) (minHSize 25 $ str "Tags")
+      <+> padLeft (Pad 5) (str "Notes")
+  renderList' = withDefAttr listAttr . drawListElements renderItem True
+  renderItem _ b listResult@ListResult{..} =
+    let marks = if
+          | lSet       -> (withAttr "set" $ str "✔✔")
+          | lInstalled -> (withAttr "installed" $ str "✓ ")
+          | otherwise  -> (withAttr "not-installed" $ str "✗ ")
+        ver = case lCross of
+          Nothing -> T.unpack . prettyVer $ lVer
+          Just c  -> T.unpack (c <> "-" <> prettyVer lVer)
+        dim
+          | lNoBindist && not lInstalled
+            && not b -- TODO: overloading dim and active ignores active
+                       --       so we hack around it here
+          = updateAttrMap (const dimAttrs) . withAttr "no-bindist"
+          | otherwise  = id
+        hooray
+          | elem Latest lTag && not lInstalled =
+              withAttr "hooray"
+          | otherwise = id
+        active = if b then forceAttr "active" else id
+    in  hooray $ active $ dim
+          (   marks
+          <+> padLeft (Pad 2)
+               ( minHSize 6
+                 (printTool lTool)
+               )
+          <+> minHSize 15 (str ver)
+          <+> (let l = catMaybes . fmap printTag $ sort lTag
+               in  padLeft (Pad 1) $ minHSize 25 $ if null l
+                     then emptyWidget
+                     else foldr1 (\x y -> x <+> str "," <+> y) l
+              )
+          <+> padLeft (Pad 5)
+              ( let notes = printNotes listResult
+                in  if null notes
+                      then emptyWidget
+                      else foldr1 (\x y -> x <+> str "," <+> y) notes
+              )
+          <+> vLimit 1 (fill ' ')
+          )
+
+  printTag Recommended    = Just $ withAttr "recommended" $ str "recommended"
+  printTag Latest         = Just $ withAttr "latest" $ str "latest"
+  printTag Prerelease     = Just $ withAttr "prerelease" $ str "prerelease"
+  printTag (Base pvp'')   = Just $ str ("base-" ++ T.unpack (prettyPVP pvp''))
+  printTag Old            = Nothing
+  printTag (UnknownTag t) = Just $ str t
+
+  printTool Cabal = str "cabal"
+  printTool GHC = str "GHC"
+  printTool GHCup = str "GHCup"
+  printTool HLS = str "HLS"
+  printTool Stack = str "Stack"
+
+  printNotes ListResult {..} =
+    (if hlsPowered then [withAttr "hls-powered" $ str "hls-powered"] else mempty
+      )
+      ++ (if fromSrc then [withAttr "compiled" $ str "compiled"] else mempty)
+      ++ (if lStray then [withAttr "stray" $ str "stray"] else mempty)
+
+  -- | Draws the list elements.
+  --
+  -- Evaluates the underlying container up to, and a bit beyond, the
+  -- selected element. The exact amount depends on available height
+  -- for drawing and 'listItemHeight'. At most, it will evaluate up to
+  -- element @(i + h + 1)@ where @i@ is the selected index and @h@ is the
+  -- available height.
+  drawListElements :: (Int -> Bool -> ListResult -> Widget String)
+                   -> Bool
+                   -> BrickInternalState
+                   -> Widget String
+  drawListElements drawElem foc is@(BrickInternalState clr _) =
+    Widget Greedy Greedy $
+      let
+        es = clr
+        listSelected        = fmap fst $ listSelectedElement' is
+
+        drawnElements = flip V.imap es $ \i' e ->
+          let addSeparator w = case es !? (i' - 1) of
+                Just e' | lTool e' /= lTool e ->
+                  hBorder <=> w
+                _                             -> w
+
+              isSelected  = Just i' == listSelected
+              elemWidget  = drawElem i' isSelected e
+              selItemAttr = if foc
+                then withDefAttr listSelectedFocusedAttr
+                else withDefAttr listSelectedAttr
+              makeVisible = if isSelected then visible . selItemAttr else id
+          in  addSeparator $ makeVisible elemWidget
+
+      in render
+        $ viewport "GHCup" Vertical
+        $ vBox
+        $ V.toList drawnElements
+
+
+minHSize :: Int -> Widget n -> Widget n
+minHSize s' = hLimit s' . vLimit 1 . (<+> fill ' ')
+
+
+app :: AttrMap -> AttrMap -> App BrickState e String
+app attrs dimAttrs =
+  App { appDraw         = \st -> [ui dimAttrs st]
+  , appHandleEvent  = eventHandler
+  , appStartEvent   = return
+  , appAttrMap      = const attrs
+  , appChooseCursor = neverShowCursor
+  }
+
+defaultAttributes :: Bool -> AttrMap
+defaultAttributes no_color = attrMap
+  Vty.defAttr
+  [ ("active"       , Vty.defAttr `withBackColor` Vty.blue)
+  , ("not-installed", Vty.defAttr `withForeColor` Vty.red)
+  , ("set"          , Vty.defAttr `withForeColor` Vty.green)
+  , ("installed"    , Vty.defAttr `withForeColor` Vty.green)
+  , ("recommended"  , Vty.defAttr `withForeColor` Vty.green)
+  , ("hls-powered"  , Vty.defAttr `withForeColor` Vty.green)
+  , ("latest"       , Vty.defAttr `withForeColor` Vty.yellow)
+  , ("prerelease"   , Vty.defAttr `withForeColor` Vty.red)
+  , ("compiled"     , Vty.defAttr `withForeColor` Vty.blue)
+  , ("stray"        , Vty.defAttr `withForeColor` Vty.blue)
+  , ("help"         , Vty.defAttr `withStyle`     Vty.italic)
+  , ("hooray"       , Vty.defAttr `withForeColor` Vty.brightWhite)
+  ]
+  where
+    withForeColor | no_color  = const
+                  | otherwise = Vty.withForeColor
+
+    withBackColor | no_color  = \attr _ -> attr `Vty.withStyle` Vty.reverseVideo
+                  | otherwise = Vty.withBackColor
+
+    withStyle                 = Vty.withStyle
+
+dimAttributes :: Bool -> AttrMap
+dimAttributes no_color = attrMap
+  (Vty.defAttr `Vty.withStyle` Vty.dim)
+  [ ("active"    , Vty.defAttr `withBackColor` Vty.blue) -- has no effect ??
+  , ("no-bindist", Vty.defAttr `Vty.withStyle` Vty.dim)
+  ]
+  where
+    withBackColor | no_color  = \attr _ -> attr `Vty.withStyle` Vty.reverseVideo
+                  | otherwise = Vty.withBackColor
+
+eventHandler :: BrickState -> BrickEvent n e -> EventM n (Next BrickState)
+eventHandler st@BrickState{..} ev = do
+  AppState { keyBindings = kb } <- liftIO $ readIORef settings'
+  case ev of
+    (MouseDown _ Vty.BScrollUp _ _) ->
+      continue (BrickState { appState = moveCursor 1 appState Up, .. })
+    (MouseDown _ Vty.BScrollDown _ _) ->
+      continue (BrickState { appState = moveCursor 1 appState Down, .. })
+    (VtyEvent (Vty.EvResize _ _)) -> continue st
+    (VtyEvent (Vty.EvKey Vty.KUp _)) ->
+      continue BrickState{ appState = moveCursor 1 appState Up, .. }
+    (VtyEvent (Vty.EvKey Vty.KDown _)) ->
+      continue BrickState{ appState = moveCursor 1 appState Down, .. }
+    (VtyEvent (Vty.EvKey key _)) ->
+      case find (\(key', _, _) -> key' == key) (keyHandlers kb) of
+        Nothing -> continue st
+        Just (_, _, handler) -> handler st
+    _ -> continue st
+
+
+moveCursor :: Int -> BrickInternalState -> Direction -> BrickInternalState
+moveCursor steps ais@BrickInternalState{..} direction =
+  let newIx = if direction == Down then ix + steps else ix - steps
+  in  case clr !? newIx of
+        Just _  -> BrickInternalState { ix = newIx, .. }
+        Nothing -> ais
+
+
+-- | Suspend the current UI and run an IO action in terminal. If the
+-- IO action returns a Left value, then it's thrown as userError.
+withIOAction :: (BrickState
+                 -> (Int, ListResult)
+                 -> ReaderT AppState IO (Either String a))
+             -> BrickState
+             -> EventM n (Next BrickState)
+withIOAction action as = case listSelectedElement' (appState as) of
+  Nothing      -> continue as
+  Just (ix, e) -> do
+    suspendAndResume $ do
+      settings <- readIORef settings'
+      flip runReaderT settings $ action as (ix, e) >>= \case
+        Left  err -> liftIO $ putStrLn ("Error: " <> err)
+        Right _   -> liftIO $ putStrLn "Success"
+      getAppData Nothing >>= \case
+        Right data' -> do
+          putStrLn "Press enter to continue"
+          _ <- getLine
+          pure (updateList data' as)
+        Left err -> throwIO $ userError err
+
+
+-- | Update app data and list internal state based on new evidence.
+-- This synchronises @BrickInternalState@ with @BrickData@
+-- and @BrickSettings@.
+updateList :: BrickData -> BrickState -> BrickState
+updateList appD BrickState{..} =
+  let newInternalState = constructList appD appSettings (Just appState)
+  in  BrickState { appState    = newInternalState
+                 , appData     = appD
+                 , appSettings = appSettings
+                 , appKeys     = appKeys
+                 }
+
+
+constructList :: BrickData
+              -> BrickSettings
+              -> Maybe BrickInternalState
+              -> BrickInternalState
+constructList appD appSettings =
+  replaceLR (filterVisible (showAllVersions appSettings)
+                           (showAllTools appSettings))
+            (lr appD)
+
+listSelectedElement' :: BrickInternalState -> Maybe (Int, ListResult)
+listSelectedElement' BrickInternalState{..} = fmap (ix, ) $ clr !? ix
+
+
+selectLatest :: Vector ListResult -> Int
+selectLatest v =
+  case V.findIndex (\ListResult {..} -> lTool == GHC && Latest `elem` lTag) v of
+    Just ix -> ix
+    Nothing -> 0
+
+
+-- | Replace the @appState@ or construct it based on a filter function
+-- and a new @[ListResult]@ evidence.
+-- When passed an existing @appState@, tries to keep the selected element.
+replaceLR :: (ListResult -> Bool)
+          -> [ListResult]
+          -> Maybe BrickInternalState
+          -> BrickInternalState
+replaceLR filterF lr s =
+  let oldElem = s >>= listSelectedElement'
+      newVec  = V.fromList . filter filterF $ lr
+      newSelected =
+        case oldElem >>= \(_, oldE) -> V.findIndex (toolEqual oldE) newVec of
+          Just ix -> ix
+          Nothing -> selectLatest newVec
+  in  BrickInternalState newVec newSelected
+ where
+  toolEqual e1 e2 =
+    lTool e1 == lTool e2 && lVer e1 == lVer e2 && lCross e1 == lCross e2
+
+
+filterVisible :: Bool -> Bool -> ListResult -> Bool
+filterVisible v t e | lInstalled e = True
+                    | v
+                    , not t
+                    , not (elem (lTool e) hiddenTools) = True
+                    | not v
+                    , t
+                    , not (elem Old (lTag e)) = True
+                    | v
+                    , t = True
+                    | otherwise = not (elem Old (lTag e)) &&
+                                  not (elem (lTool e) hiddenTools)
+
+
+install' :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadFail m, MonadMask m, MonadUnliftIO m)
+         => BrickState
+         -> (Int, ListResult)
+         -> m (Either String ())
+install' _ (_, ListResult {..}) = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+
+  l        <- liftIO $ readIORef logger'
+  let runLogger = myLoggerT l
+
+  let run =
+        runLogger
+          . runResourceT
+          . runE
+            @'[ AlreadyInstalled
+#if !defined(TAR)
+              , ArchiveResult
+#endif
+              , UnknownArchive
+              , FileDoesNotExistError
+              , CopyError
+              , NoDownload
+              , NotInstalled
+              , BuildFailed
+              , TagNotFound
+              , DigestError
+              , DownloadFailed
+              , NoUpdate
+              , TarDirDoesNotExist
+              ]
+
+  run (do
+      case lTool of
+        GHC   -> do
+          let vi = getVersionInfo lVer GHC dls
+          liftE $ installGHCBin lVer $> vi
+        Cabal -> do
+          let vi = getVersionInfo lVer Cabal dls
+          liftE $ installCabalBin lVer $> 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 $> vi
+        Stack -> do
+          let vi = getVersionInfo lVer Stack dls
+          liftE $ installStackBin lVer $> vi
+    )
+    >>= \case
+          VRight vi                         -> do
+            forM_ (_viPostInstall =<< vi) $ \msg ->
+              myLoggerT l $ $(logInfo) msg
+            pure $ Right ()
+          VLeft  (V (AlreadyInstalled _ _)) -> pure $ Right ()
+          VLeft (V NoUpdate) -> pure $ Right ()
+          VLeft e -> pure $ Left [i|#{prettyShow e}
+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
+          . runE @'[FileDoesNotExistError , NotInstalled , TagNotFound]
+
+  run (do
+      case lTool of
+        GHC   -> liftE $ setGHC (GHCTargetVersion lCross lVer) SetGHCOnly $> ()
+        Cabal -> liftE $ setCabal lVer $> ()
+        HLS   -> liftE $ setHLS lVer $> ()
+        Stack -> liftE $ setStack lVer $> ()
+        GHCup -> pure ()
+    )
+    >>= \case
+          VRight _ -> pure $ Right ()
+          VLeft  e -> pure $ Left (prettyShow e)
+
+
+del' :: (MonadReader AppState m, MonadIO m, MonadFail m, MonadMask m, MonadUnliftIO m)
+     => BrickState
+     -> (Int, ListResult)
+     -> m (Either String ())
+del' _ (_, ListResult {..}) = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+
+  l <- liftIO $ readIORef logger'
+  let runLogger = myLoggerT l
+  let run = myLoggerT l . runE @'[NotInstalled]
+
+  run (do
+      let vi = getVersionInfo lVer lTool dls
+      case lTool of
+        GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> vi
+        Cabal -> liftE $ rmCabalVer lVer $> vi
+        HLS   -> liftE $ rmHLSVer lVer $> vi
+        Stack -> liftE $ rmStackVer lVer $> vi
+        GHCup -> pure Nothing
+    )
+    >>= \case
+          VRight vi -> do
+            forM_ (join $ fmap _viPostRemove vi) $ \msg ->
+              runLogger $ $(logInfo) msg
+            pure $ Right ()
+          VLeft  e -> pure $ Left (prettyShow e)
+
+
+changelog' :: (MonadReader AppState m, MonadIO m)
+           => BrickState
+           -> (Int, ListResult)
+           -> m (Either String ())
+changelog' _ (_, ListResult {..}) = do
+  AppState { pfreq, ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+  case getChangeLog dls lTool (Left lVer) of
+    Nothing -> pure $ Left
+      [i|Could not find ChangeLog for #{lTool}, version #{prettyVer lVer}|]
+    Just uri -> do
+      let cmd = case _rPlatform pfreq of
+            Darwin  -> "open"
+            Linux _ -> "xdg-open"
+            FreeBSD -> "xdg-open"
+            Windows -> "start"
+      exec cmd [T.unpack $ decUTF8Safe $ serializeURIRef' uri] Nothing Nothing >>= \case
+        Right _ -> pure $ Right ()
+        Left  e -> pure $ Left $ prettyShow e
+
+
+settings' :: IORef AppState
+{-# NOINLINE settings' #-}
+settings' = unsafePerformIO $ do
+  dirs <- getDirs
+  newIORef $ AppState (Settings { cache      = True
+                                , noVerify   = False
+                                , keepDirs   = Never
+                                , downloader = Curl
+                                , verbose    = False
+                                , urlSource  = GHCupURL
+                                , ..
+                                })
+                      dirs
+                      defaultKeyBindings
+                      (GHCupInfo mempty mempty mempty)
+                      (PlatformRequest A_64 Darwin Nothing)
+
+
+
+logger' :: IORef LoggerConfig
+{-# NOINLINE logger' #-}
+logger' = unsafePerformIO
+  (newIORef $ LoggerConfig { lcPrintDebug = False
+                           , colorOutter  = \_ -> pure ()
+                           , rawOutter    = \_ -> pure ()
+                           }
+  )
+
+
+brickMain :: AppState
+          -> LoggerConfig
+          -> GHCupInfo
+          -> IO ()
+brickMain s l gi = do
+  writeIORef settings' s
+  -- logger interpreter
+  writeIORef logger'   l
+  let runLogger = myLoggerT l
+
+  no_color <- isJust <$> lookupEnv "NO_COLOR"
+
+  eAppData <- getAppData (Just gi)
+  case eAppData of
+    Right ad ->
+      defaultMain
+          (app (defaultAttributes no_color) (dimAttributes no_color))
+          (BrickState ad
+                    defaultAppSettings
+                    (constructList ad defaultAppSettings Nothing)
+                    (keyBindings s)
+
+          )
+        $> ()
+    Left e -> do
+      runLogger ($(logError) [i|Error building app state: #{show e}|])
+      exitWith $ ExitFailure 2
+
+
+defaultAppSettings :: BrickSettings
+defaultAppSettings = BrickSettings { showAllVersions = False, showAllTools = False }
+
+
+getGHCupInfo :: IO (Either String GHCupInfo)
+getGHCupInfo = do
+  settings <- readIORef settings'
+  l        <- readIORef logger'
+  let runLogger = myLoggerT l
+
+  r <-
+    runLogger
+    . flip runReaderT settings
+    . runE @'[JSONError , DownloadFailed , FileDoesNotExistError]
+    $ liftE
+    $ getDownloadsF (GT.settings settings) (GT.dirs settings)
+
+  case r of
+    VRight a -> pure $ Right a
+    VLeft  e -> pure $ Left (prettyShow e)
+
+
+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
+    lV <- listVersions Nothing Nothing
+    pure $ BrickData (reverse lV)
+

bootstrap-haskell

@@ -1,123 +1,264 @@
 #!/bin/sh
 
+# Main settings:
+#   * BOOTSTRAP_HASKELL_NONINTERACTIVE - any nonzero value for noninteractive installation
+#   * BOOTSTRAP_HASKELL_NO_UPGRADE - any nonzero value to not trigger the upgrade
+#   * 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
+#   * BOOTSTRAP_HASKELL_CABAL_VERSION
+
+# License: LGPL-3.0
+
+
 # safety subshell to avoid executing anything in case this script is not downloaded properly
 (
 
-: "${GHCUP_INSTALL_BASE_PREFIX:=$HOME}"
+plat="$(uname -s)"
+arch=$(uname -m)
+ghver="0.1.14.1"
+base_url="https://downloads.haskell.org/~ghcup"
+
+case "${plat}" in
+        MSYS*|MINGW*)
+			: "${GHCUP_INSTALL_BASE_PREFIX:=/c}"
+			GHCUP_DIR=${GHCUP_INSTALL_BASE_PREFIX}/ghcup
+			GHCUP_BIN=${GHCUP_INSTALL_BASE_PREFIX}/ghcup/bin
+			;;
+		*)
+			: "${GHCUP_INSTALL_BASE_PREFIX:=$HOME}"
+			export GHCUP_USE_XDG_DIRS
+
+			if [ -n "${GHCUP_USE_XDG_DIRS}" ] ; then
+				GHCUP_DIR=${XDG_DATA_HOME:=$HOME/.local/share}/ghcup
+				GHCUP_BIN=${XDG_BIN_HOME:=$HOME/.local/bin}
+			else
+				GHCUP_DIR=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup
+				GHCUP_BIN=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin
+			fi
+			;;
+esac
+
+: "${BOOTSTRAP_HASKELL_GHC_VERSION:=recommended}"
+: "${BOOTSTRAP_HASKELL_CABAL_VERSION:=recommended}"
+
 
 die() {
     (>&2 printf "\\033[0;31m%s\\033[0m\\n" "$1")
     exit 2
 }
 
-edo()
-{
+warn() {
+	case "${plat}" in
+			MSYS*|MINGW*)
+				echo -e "\\033[0;35m$1\\033[0m"
+				;;
+			*)
+				printf "\\033[0;35m%s\\033[0m\\n" "$1"
+				;;
+	esac
+}
+
+edo() {
     "$@" || die "\"$*\" failed!"
 }
 
 eghcup() {
+	edo _eghcup "$@"
+}
+
+_eghcup() {
+	if [ -n "${BOOTSTRAP_HASKELL_YAML}" ] ; then
+		args="-s ${BOOTSTRAP_HASKELL_YAML}"
+	fi 
     if [ -z "${BOOTSTRAP_HASKELL_VERBOSE}" ] ; then
-        edo ghcup "$@"
+        ghcup ${args} "$@"
     else
-        edo ghcup --verbose "$@"
+        ghcup ${args} --verbose "$@"
     fi
 }
 
-download_ghcup() {
-	_plat="$(uname -s)"
-	_arch=$(uname -m)
+_done() {
+	case "${plat}" in
+			MSYS*|MINGW*)
+				echo
+				echo "All done!"
+				echo
+				echo "In a new powershell or cmd.exe session, now you can..."
+				echo
+				echo "Start a simple repl via:"
+				echo "  ghci"
+				echo
+				echo "Start a new haskell project in the current directory via:"
+				echo "  cabal init --interactive"
+				echo
+				echo "Install other GHC versions and tools via:"
+				echo "  ghcup list"
+				echo "  ghcup install <tool> <version>"
+				echo
+				echo "To install system libraries and update msys2/mingw64,"
+				echo "open the \"Mingw haskell shell\""
+				echo "and the \"Mingw package management docs\""
+				echo "desktop shortcuts."
+				;;
+			*)
+				echo
+				echo "All done!"
+				echo
+				echo "To start a simple repl, run:"
+				echo "  ghci"
+				echo
+				echo "To start a new haskell project in the current directory, run:"
+				echo "  cabal init --interactive"
+				echo
+				echo "To install other GHC versions and tools, run:"
+				echo "  ghcup tui"
+				;;
 
-    case "${_plat}" in
+	esac
+
+
+	exit 0
+}
+
+download_ghcup() {
+
+    case "${plat}" in
         "linux"|"Linux")
-			case "${_arch}" in
+			case "${arch}" in
 				x86_64|amd64)
-					_url=https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup
+					# 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}/i386-linux-ghcup-${ghver}
+					elif [ "$(getconf LONG_BIT)" = "64" ] ; then
+						_url=${base_url}/${ghver}/x86_64-linux-ghcup-${ghver}
+					else
+						die "Unknown long bit size: $(getconf LONG_BIT)"
+					fi
 					;;
 				i*86)
-					_url=https://downloads.haskell.org/~ghcup/i386-linux-ghcup
+					_url=${base_url}/${ghver}/i386-linux-ghcup-${ghver}
 					;;
-				*) die "Unknown architecture: ${_arch}"
+				armv7*)
+					_url=${base_url}/${ghver}/armv7-linux-ghcup-${ghver}
+					;;
+				aarch64|arm64|armv8l)
+					_url=${base_url}/${ghver}/aarch64-linux-ghcup-${ghver}
+					;;
+				*) die "Unknown architecture: ${arch}"
 					;;
 			esac
 			;;
         "FreeBSD"|"freebsd")
-			case "${_arch}" in
+			case "${arch}" in
 				x86_64|amd64)
 					;;
 				i*86)
 					die "i386 currently not supported!"
 					;;
-				*) die "Unknown architecture: ${_arch}"
+				*) die "Unknown architecture: ${arch}"
 					;;
 			esac
-			_url=https://downloads.haskell.org/~ghcup/x86_64-portbld-freebsd-ghcup
+			_url=${base_url}/${ghver}/x86_64-portbld-freebsd-ghcup-${ghver}
             ;;
         "Darwin"|"darwin")
-			case "${_arch}" in
+			case "${arch}" in
 				x86_64|amd64)
 					;;
 				i*86)
 					die "i386 currently not supported!"
 					;;
-				*) die "Unknown architecture: ${_arch}"
+				*) die "Unknown architecture: ${arch}"
 					;;
 			esac
-			_url=https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup ;;
-        *) die "Unknown platform: ${_plat}"
+			_url=${base_url}/${ghver}/x86_64-apple-darwin-ghcup-${ghver} ;;
+        MSYS*|MINGW*)
+			case "${arch}" in
+				x86_64|amd64)
+					_url=https://downloads.haskell.org/~ghcup/tmp/x86_64-mingw64-ghcup-7.exe
+					;;
+				*) die "Unknown architecture: ${arch}"
+					;;
+			esac
+			;;
+        *) die "Unknown platform: ${plat}"
 			;;
     esac
+    case "${plat}" in
+        MSYS*|MINGW*)
+			edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup.exe
+			edo chmod +x "${GHCUP_BIN}"/ghcup.exe
+			;;
+		*)
+			edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup
+			edo chmod +x "${GHCUP_BIN}"/ghcup
+			;;
+	esac
 
-	edo curl -Lf "${_url}" > "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/ghcup
-
-	unset _plat _arch _url
+  edo mkdir -p "${GHCUP_DIR}"
+	cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
+		export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
+		EOF
+	# shellcheck disable=SC1090
+    edo . "${GHCUP_DIR}"/env
+    eghcup upgrade
 }
 
 
 echo
 echo "Welcome to Haskell!"
 echo
-echo "This will download and install the Glasgow Haskell Compiler (GHC)"
-echo "and the Cabal build tool."
+echo "This script will download and install the following binaries:"
+echo "  * ghcup - The Haskell toolchain installer"
+echo "  * ghc   - The Glasgow Haskell Compiler"
+echo "  * cabal - The Cabal build tool for managing Haskell software"
+echo "  * stack - (optional) A cross-platform program for developing Haskell projects"
+echo "  * hls   - (optional) A language server for developers to integrate with their editor/IDE"
 echo
-echo "ghcup installs only into the following directory, which can be removed anytime:"
-echo "  $GHCUP_INSTALL_BASE_PREFIX/.ghcup"
+if [ -z "${GHCUP_USE_XDG_DIRS}" ] ; then
+	echo "ghcup installs only into the following directory,"
+    echo "which can be removed anytime:"
+	case "${plat}" in
+			MSYS*|MINGW*)
+				echo "  $(cygpath -w "$GHCUP_DIR")"
+				;;
+			*)
+				echo "  $GHCUP_DIR"
+				;;
+	esac
+else
+	echo "ghcup installs into XDG directories as long as"
+    echo "'GHCUP_USE_XDG_DIRS' is set."
+fi
 echo
 
 if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-    printf "\\033[0;35m%s\\033[0m\\n" "Press ENTER to proceed"
-    printf "\\033[0;35m%s\\033[0m\\n" "or ctrl-c to abort."
-    printf "\\033[0;35m%s\\033[0m\\n" "Note that this script can be re-run at any given time."
+    warn "Press ENTER to proceed or ctrl-c to abort."
+    warn "Note that this script can be re-run at any given time."
     echo
     # Wait for user input to continue.
     # shellcheck disable=SC2034
     read -r answer </dev/tty
 fi
 
-edo mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
+edo mkdir -p "${GHCUP_BIN}"
 
 if command -V "ghcup" >/dev/null 2>&1 ; then
     if [ -z "${BOOTSTRAP_HASKELL_NO_UPGRADE}" ] ; then
-        eghcup upgrade
+        _eghcup upgrade || download_ghcup
     fi
 else
 	download_ghcup
-    edo chmod +x "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/ghcup
-
-	cat <<-EOF > "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/env || die "Failed to create env file"
-		export PATH="\$HOME/.cabal/bin:\${GHCUP_INSTALL_BASE_PREFIX:=\$HOME}/.ghcup/bin:\$PATH"
-		EOF
-	# shellcheck disable=SC1090
-    edo . "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/env
 fi
 
 echo
-echo "$(ghcup tool-requirements)"
+echo "$(if [ -n "${BOOTSTRAP_HASKELL_YAML}" ] ; then ghcup -s "${BOOTSTRAP_HASKELL_YAML}" tool-requirements ; else ghcup tool-requirements ; fi)"
 echo
 
 if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-    printf "\\033[0;35m%s\\033[0m\\n" "Press ENTER to proceed"
-    printf "\\033[0;35m%s\\033[0m\\n" "or ctrl-c to abort."
-    printf "\\033[0;35m%s\\033[0m\\n" "Installation may take a while."
+    warn "Press ENTER to proceed or ctrl-c to abort."
+    warn "Installation may take a while."
     echo
 
     # Wait for user input to continue.
@@ -125,20 +266,109 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
     read -r answer </dev/tty
 fi
 
-eghcup --cache install
+eghcup --cache install ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
+
+eghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
+eghcup --cache install cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
+
+adjust_cabal_config() {
+	edo cabal user-config -a "extra-prog-path: $(cygpath -w $GHCUP_BIN), $(cygpath -w "$HOME"/AppData/Roaming/cabal/bin), $(cygpath -w "$GHCUP_DIR"/msys64/usr/bin), $(cygpath -w "$GHCUP_DIR"/msys64/mingw64/bin)" -a "extra-include-dirs: $(cygpath -w "$GHCUP_DIR"/msys64/mingw64/include)" -a "extra-lib-dirs: $(cygpath -w "$GHCUP_DIR"/msys64/mingw64/lib)" -f init
+}
+
+case "${plat}" in
+        MSYS*|MINGW*)
+			if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+				warn "Create an initial cabal.config including relevant msys2 paths (recommended)?"
+				warn "[Y] Yes  [N] No  [?] Help (default is \"Y\")."
+				echo
+				while true; do
+					read -r mingw_answer </dev/tty
+
+					case $mingw_answer in
+						[Yy]* | "")
+							adjust_cabal_config
+							break ;;
+						[Nn]*)
+							echo "Make sure that your global cabal.config references the correct mingw64 paths (extra-prog-path, extra-include-dirs and extra-lib-dirs)."
+							sleep 5
+							break ;;
+						*)
+							echo "Possible choices are:"
+							echo
+							echo "Y - Yes, create a cabal.config with pre-set paths to msys2/mingw64 (default)"
+							echo "N - No, leave the current/default cabal config untouched"
+							echo
+							echo "Please make your choice and press ENTER."
+							;;
+					esac
+				done
+			else
+				adjust_cabal_config
+			fi
+			;;
+esac
 
-eghcup set
-eghcup --cache install-cabal
 
 edo cabal new-update
 
-printf "\\033[0;35m%s\\033[0m\\n" ""
-printf "\\033[0;35m%s\\033[0m\\n" "Installation done!"
-printf "\\033[0;35m%s\\033[0m\\n" ""
-
 if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+	warn "Do you want to install haskell-language-server (HLS) now?"
+	warn "HLS is a language-server that provides IDE-like functionality"
+	warn "and can integrate with different editors, such as Vim, Emacs, VS Code, Atom, ..."
+	warn "Also see https://github.com/haskell/haskell-language-server/blob/master/README.md"
+	warn ""
+	warn "[Y] Yes  [N] No  [?] Help (default is \"N\")."
+	warn ""
+
+	while true; do
+		read -r hls_answer </dev/tty
+
+		case $hls_answer in
+			[Yy]*)
+				eghcup --cache install hls
+				break ;;
+			[Nn]* | "")
+				break ;;
+			*)
+				echo "Possible choices are:"
+				echo
+				echo "Y - Yes, install the haskell-langauge-server"
+				echo "N - No, don't install anything more (default)"
+				echo
+				echo "Please make your choice and press ENTER."
+				;;
+		esac
+	done
+
+	warn "Do you want to install stack now?"
+	warn "Stack is a haskell build tool similar to cabal that is used by some projects."
+	warn "Also see https://docs.haskellstack.org/"
+	warn ""
+	warn "[Y] Yes  [N] No  [?] Help (default is \"N\")."
+	warn ""
+
+	while true; do
+		read -r stack_answer </dev/tty
+
+		case $stack_answer in
+			[Yy]*)
+				eghcup --cache install stack
+				break ;;
+			[Nn]* | "")
+				break ;;
+			*)
+				echo "Possible choices are:"
+				echo
+				echo "Y - Yes, install stack"
+				echo "N - No, don't install anything more (default)"
+				echo
+				echo "Please make your choice and press ENTER."
+				;;
+		esac
+	done
+
     echo "In order to run ghc and cabal, you need to adjust your PATH variable."
-    echo "You may want to source '$GHCUP_INSTALL_BASE_PREFIX/.ghcup/env' in your shell"
+    echo "You may want to source '$GHCUP_DIR/env' in your shell"
     echo "configuration to do so (e.g. ~/.bashrc)."
 
 	case $SHELL in
@@ -146,55 +376,87 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 			GHCUP_PROFILE_FILE="$HOME/.zshrc"
 			MY_SHELL="zsh" ;;
 		*/bash) # login shell is bash
-			if [ -f "$HOME/.bashrc" ] ; then # bashrc is not sourced by default, so assume it isn't if file does not exist
-				GHCUP_PROFILE_FILE="$HOME/.bashrc"
-			else
-				GHCUP_PROFILE_FILE="$HOME/.bash_profile"
-			fi
-
+			GHCUP_PROFILE_FILE="$HOME/.bashrc"
 			MY_SHELL="bash" ;;
 		*/sh) # login shell is sh, but might be a symlink to bash or zsh
 			if [ -n "${BASH}" ] ; then
-				if [ -f "$HOME/.bashrc" ] ; then # bashrc is not sourced by default, so assume it isn't if file does not exist
-					GHCUP_PROFILE_FILE="$HOME/.bashrc"
-				else
-					GHCUP_PROFILE_FILE="$HOME/.bash_profile"
-				fi
-
+				GHCUP_PROFILE_FILE="$HOME/.bashrc"
 				MY_SHELL="bash"
 			elif [ -n "${ZSH_VERSION}" ] ; then
 				GHCUP_PROFILE_FILE="$HOME/.zshrc"
 				MY_SHELL="zsh"
 			else
-				exit 0
+			    _done
 			fi
 			;;
-		*) exit 0 ;;
+		*/fish) # login shell is fish
+			GHCUP_PROFILE_FILE="$HOME/.config/fish/config.fish"
+			MY_SHELL="fish" ;;
+		*) _done ;;
 	esac
 
 
-	printf "\\033[0;35m%s\\033[0m\\n" ""
-	printf "\\033[0;35m%s\\033[0m\\n" "Detected ${MY_SHELL} shell on your system..."
-	printf "\\033[0;35m%s\\033[0m\\n" "If you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\""
-	printf "\\033[0;35m%s\\033[0m\\n" "answer with YES, otherwise with NO and press ENTER."
-	printf "\\033[0;35m%s\\033[0m\\n" ""
+	warn ""
+	warn "Detected ${MY_SHELL} shell on your system..."
+	warn "If you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\""
+	warn ""
+	warn "[Y] Yes  [N] No  [?] Help (default is \"Y\")."
+	warn ""
 
     while true; do
         read -r next_answer </dev/tty
 
         case $next_answer in
-            [Yy]*)
-                echo "[ -f \"\${GHCUP_INSTALL_BASE_PREFIX:=\$HOME}/.ghcup/env\" ] && source \"\${GHCUP_INSTALL_BASE_PREFIX:=\$HOME}/.ghcup/env\"" >> "${GHCUP_PROFILE_FILE}"
-                printf "\\033[0;35m%s\\033[0m\\n" "OK! ${GHCUP_PROFILE_FILE} has been modified. Restart your terminal for the changes to take effect,"
-                printf "\\033[0;35m%s\\033[0m\\n" "or type \"source ${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/env\" to apply them in your current terminal session."
-                exit 0;;
             [Nn]*)
-                exit 0;;
-            *)
-                echo "Please type YES or NO and press enter.";;
+                _done ;;
+            [Yy]* | "")
+				case $MY_SHELL in
+					"") break ;;
+					fish)
+						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
+							mkdir -p "${GHCUP_PROFILE_FILE%/*}"
+							echo "# ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME" >> "${GHCUP_PROFILE_FILE}"
+							echo "test -f $GHCUP_DIR/env ; and set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH" >> "${GHCUP_PROFILE_FILE}"
+						fi
+						break ;;
+					bash)
+						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
+							echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+						fi
+						case "${plat}" in
+							"Darwin"|"darwin")
+								if ! grep -q "ghcup-env" "${HOME}/.bash_profile" ; then
+									echo "[[ -f ~/.bashrc ]] && source ~/.bashrc # ghcup-env" >> "${HOME}/.bash_profile"
+								fi
+								;;
+						esac
+						break ;;
+
+					zsh)
+						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
+							echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+						fi
+						break ;;
+				esac
+                warn "OK! ${GHCUP_PROFILE_FILE} has been modified. Restart your terminal for the changes to take effect,"
+                warn "or type \"source ${GHCUP_DIR}/env\" to apply them in your current terminal session."
+				_done
+                ;;
+			*)
+				echo "Possible choices are:"
+				echo
+				echo "Y - Yes, update my \"${GHCUP_PROFILE_FILE}\" (default)"
+				echo "N - No, don't mess with my configuration"
+				echo
+				echo "Please make your choice and press ENTER."
+				;;
         esac
     done
 fi
+
+_done
+
 )
 
 # vim: tabstop=4 shiftwidth=4 expandtab

bootstrap-haskell.ps1

@@ -0,0 +1,194 @@
+function Print-Msg {
+  param ( [Parameter(Mandatory=$true, HelpMessage='String to output')][string]$msg )
+  Write-Host ('{0}' -f $msg) -ForegroundColor Green
+}
+
+function Create-Shortcut {
+    param ( [Parameter(Mandatory=$true,HelpMessage='Target path')][string]$SourceExe, [Parameter(Mandatory=$true,HelpMessage='Arguments to the path/exe')][AllowEmptyString()]$ArgumentsToSourceExe, [Parameter(Mandatory=$true,HelpMessage='The destination of the desktop link')][string]$DestinationPath )
+    $WshShell = New-Object -comObject WScript.Shell
+    $Shortcut = $WshShell.CreateShortcut($DestinationPath)
+    $Shortcut.TargetPath = $SourceExe
+    if($ArgumentsToSourceExe) {
+      $Shortcut.Arguments = $ArgumentsToSourceExe
+    }
+    $Shortcut.Save()
+}
+
+function Add-EnvPath {
+    param(
+        [Parameter(Mandatory=$true,HelpMessage='The Pathe to add to Users environment')]
+        [string] $Path,
+
+        [ValidateSet('Machine', 'User', 'Session')]
+        [string] $Container = 'Session'
+    )
+
+    function Where-Something
+    {
+      param
+      (
+        [Parameter(Mandatory=$true, ValueFromPipeline=$true, HelpMessage='Data to filter')]
+        $InputObject
+      )
+      process
+      {
+        if ($InputObject)
+        {
+          $InputObject
+        }
+      }
+    }
+
+  if ($Container -ne 'Session') {
+        $containerMapping = @{
+            Machine = [EnvironmentVariableTarget]::Machine
+            User = [EnvironmentVariableTarget]::User
+        }
+        $containerType = $containerMapping[$Container]
+
+        $persistedPaths = [Environment]::GetEnvironmentVariable('Path', $containerType) -split ';'
+        if ($persistedPaths -notcontains $Path) {
+            $persistedPaths = $persistedPaths + $Path | Where-Something
+            [Environment]::SetEnvironmentVariable('Path', $persistedPaths -join ';', $containerType)
+        }
+    }
+
+    $envPaths = $env:Path -split ';'
+    if ($envPaths -notcontains $Path) {
+        $envPaths = $envPaths + $Path | Where-Something
+        $env:Path = $envPaths -join ';'
+    }
+}
+
+filter Get-FileSize {
+	'{0:N2} {1}' -f $(
+	if ($_ -lt 1kb) { $_, 'Bytes' }
+	elseif ($_ -lt 1mb) { ($_/1kb), 'KB' }
+	elseif ($_ -lt 1gb) { ($_/1mb), 'MB' }
+	elseif ($_ -lt 1tb) { ($_/1gb), 'GB' }
+	elseif ($_ -lt 1pb) { ($_/1tb), 'TB' }
+	else { ($_/1pb), 'PB' }
+	)
+}
+
+function Get-FileWCSynchronous{
+    param(
+        [Parameter(Mandatory=$true)]
+        [string]$url, 
+        [string]$destinationFolder="$env:USERPROFILE\Downloads",
+        [switch]$includeStats
+    )
+    $wc = New-Object -TypeName Net.WebClient
+    $wc.UseDefaultCredentials = $true
+    $destination = Join-Path -Path $destinationFolder -ChildPath ($url | Split-Path -Leaf)
+    $start = Get-Date
+    $wc.DownloadFile($url, $destination)
+    $elapsed = ((Get-Date) - $start).ToString('hh\:mm\:ss')
+    $totalSize = (Get-Item -Path $destination).Length | Get-FileSize
+    if ($includeStats.IsPresent){
+        [PSCustomObject]@{Name=$MyInvocation.MyCommand;TotalSize=$totalSize;Time=$elapsed}
+    }
+    Get-Item -Path $destination | Unblock-File
+}
+
+$ErrorActionPreference = 'Stop'
+
+$GhcupDir = "$env:HOMEDRIVE\ghcup"
+$MsysDir = ('{0}\msys64' -f $GhcupDir)
+$Bash = ('{0}\usr\bin\bash' -f $MsysDir)
+
+Print-Msg -msg 'Preparing for GHCup installation...'
+
+if (Test-Path -Path ('{0}' -f $GhcupDir)) {
+  $decision = $Host.UI.PromptForChoice('Install', 'GHCup is already installed, what do you want to do?', @('&Reinstall'
+                                                                                                           '&Continue'
+                                                                                                           '&Abort'), 1)
+  if ($decision -eq 0) {
+    $suffix = [IO.Path]::GetRandomFileName()
+    Print-Msg -msg ('Backing up {0} to {0}-{1} ...' -f $GhcupDir, $suffix)
+    Rename-Item -Path ('{0}' -f $GhcupDir) -NewName ('{0}-{1}' -f $GhcupDir, $suffix)
+  } elseif ($decision -eq 1) {
+    Print-Msg -msg 'Continuing installation...'
+  } elseif ($decision -eq 2) {
+    Exit
+  }
+}
+
+
+$null = New-Item -Path ('{0}' -f $GhcupDir) -ItemType 'directory' -ErrorAction SilentlyContinue
+$null = New-Item -Path ('{0}' -f $GhcupDir) -Name 'bin' -ItemType 'directory' -ErrorAction SilentlyContinue
+
+Print-Msg -msg 'First checking for Msys2...'
+
+if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
+    Print-Msg -msg ('...Msys2 doesn''t exist, installing into {0} ...this may take a while' -f $MsysDir)
+
+    # Download the archive
+    Print-Msg -msg 'Downloading Msys2 archive...'
+    $archive = 'msys2-x86_64-latest.sfx.exe'
+    
+    if (Get-Command -Name 'curl.exe' -ErrorAction SilentlyContinue) {
+      curl.exe -o ('{0}\{1}' -f $env:TEMP, $archive) ('https://repo.msys2.org/distrib/{0}' -f $archive)
+    } else {
+      Get-FileWCSynchronous -url ('https://repo.msys2.org/distrib/{0}' -f $archive) -destinationFolder "$env:TEMP" -includeStats
+    }
+
+    Print-Msg -msg 'Extracting Msys2 archive...'
+    $null = & "$env:TEMP\$archive" '-y' ('-o{0}' -f $GhcupDir)  # Extract
+    Remove-Item -Path ('{0}/{1}' -f $env:TEMP, $archive)
+
+    Print-Msg -msg 'Processing MSYS2 bash for first time use...'
+    & "$Bash" -lc 'exit'
+
+    & "$env:windir\system32\taskkill.exe" /F /FI `"MODULES eq msys-2.0.dll`"
+
+    Print-Msg -msg 'Upgrading full system...'
+    & "$Bash" -lc 'pacman --noconfirm -Syuu'
+
+    Print-Msg -msg 'Upgrading full system twice...'
+    & "$Bash" -lc 'pacman --noconfirm -Syuu'
+
+    Print-Msg -msg 'Installing GHC Build Dependencies...'
+    & "$Bash" -lc 'pacman --noconfirm -S --needed git tar curl wget base-devel gettext binutils autoconf make libtool automake python p7zip patch unzip mingw-w64-x86_64-toolchain mingw-w64-x86_64-gcc mingw-w64-x86_64-gdb mingw-w64-x86_64-python2 mingw-w64-x86_64-python3-sphinx'
+
+    Print-Msg -msg 'Updating SSL root certificate authorities...'
+    & "$Bash" -lc 'pacman --noconfirm -S ca-certificates'
+
+    Print-Msg -msg 'Setting default home directory...'
+    & "$Bash" -lc "sed -i -e 's/db_home:.*$/db_home: windows/' /etc/nsswitch.conf"
+} else {
+    Print-Msg -msg ('...Msys2 found in {0} ...skipping Msys2 installation.' -f $MsysDir)
+}
+
+Print-Msg -msg 'Creating shortcuts...'
+Create-Shortcut -SourceExe ('{0}\msys2_shell.cmd' -f $MsysDir) -ArgumentsToSourceExe '-mingw64' -DestinationPath ('{0}\Desktop\Mingw haskell shell.lnk' -f $HOME)
+Create-Shortcut -SourceExe 'https://www.msys2.org/docs/package-management' -ArgumentsToSourceExe '' -DestinationPath ('{0}\Desktop\Mingw package management docs.url' -f $HOME)
+
+Print-Msg -msg ('Adding {0}\bin to Users Path...' -f $GhcupDir)
+Add-EnvPath -Path ('{0}\bin' -f $GhcupDir) -Container 'User'
+
+Print-Msg -msg 'Starting GHCup installer...'
+& "$Bash" -lc "export PATH=`"/c/ghcup/bin:`$PATH`" ; curl --proto =https --tlsv1.2 -sSf https://gitlab.haskell.org/haskell/ghcup-hs/-/raw/windows-support/bootstrap-haskell | bash"
+# SIG # Begin signature block
+  # MIID4QYJKoZIhvcNAQcCoIID0jCCA84CAQExCzAJBgUrDgMCGgUAMGkGCisGAQQB
+  # gjcCAQSgWzBZMDQGCisGAQQBgjcCAR4wJgIDAQAABBAfzDtgWUsITrck0sYpfvNR
+  # AgEAAgEAAgEAAgEAAgEAMCEwCQYFKw4DAhoFAAQUVqKek181kF/Jx/P7z176herc
+  # ZyCgggH/MIIB+zCCAWSgAwIBAgIQGOezhGS1A5tHh9VubW0liDANBgkqhkiG9w0B
+  # AQUFADAYMRYwFAYDVQQDDA1KdWxpYW4gT3NwYWxkMB4XDTIxMDUzMDE4Mzk1OVoX
+  # DTI1MDUzMDAwMDAwMFowGDEWMBQGA1UEAwwNSnVsaWFuIE9zcGFsZDCBnzANBgkq
+  # hkiG9w0BAQEFAAOBjQAwgYkCgYEAs76XCXYPM14buR1RkVKhOB8pyM4Df6kPaz75
+  # nkbA0nq1VmMhBfCYFWyYHd7jniqTH0LoAKGGquN1bniREaCP9j2pFWpMIgLpQH3H
+  # +jpsfmxV2BTG8q+Jok88gTXS1FlAk72E85zO/Jhr6Fja1aFYAdibBRsRxcVMTVh7
+  # 4AGLNGUCAwEAAaNGMEQwEwYDVR0lBAwwCgYIKwYBBQUHAwMwHQYDVR0OBBYEFC+R
+  # hdhPo0Ty5HnzHyo1pN35IfZQMA4GA1UdDwEB/wQEAwIHgDANBgkqhkiG9w0BAQUF
+  # AAOBgQAl3IdBVIwbJJDp7BksMYPeM4ivB3UyNvlw8aVxGwAzNgdSaezYIdMFtKXV
+  # CSv5bd4VnFRAPDJW9dhW0h3SkeJUoklUxMjKXhR3qygQhSxPDjIatAuOCffGACba
+  # ZZ7Om40b+pKXc6i/HnlApk9DGbXJ59bFcLGGcZ9QjoUae6Ex1DGCAUwwggFIAgEB
+  # MCwwGDEWMBQGA1UEAwwNSnVsaWFuIE9zcGFsZAIQGOezhGS1A5tHh9VubW0liDAJ
+  # BgUrDgMCGgUAoHgwGAYKKwYBBAGCNwIBDDEKMAigAoAAoQKAADAZBgkqhkiG9w0B
+  # CQMxDAYKKwYBBAGCNwIBBDAcBgorBgEEAYI3AgELMQ4wDAYKKwYBBAGCNwIBFTAj
+  # BgkqhkiG9w0BCQQxFgQUosm9nN1JgajqSBa1cUwxxhLrAsYwDQYJKoZIhvcNAQEB
+  # BQAEgYCnKzfsH1aDjS6xkC/uymjaBowHSnh6nFu2AkjcKu8RgcBZzP5SLBXgU9wm
+  # aED5Ujwyq3Qre+TGVRUqwkEauDhQiX2A008G00fRO6+di6yJRCRn5eaRAbdU3Xww
+  # E5VhEwLBnwzWrvLKtdEclhgUCo5Tq87QMXVdgX4aRmunl4ZE+Q==
+# SIG # End signature block

cabal.ghc8104.project

@@ -0,0 +1,20 @@
+packages: ./ghcup.cabal
+
+with-compiler: ghc-8.10.4
+
+optional-packages: ./3rdparty/*/*.cabal
+
+optimization: 2
+
+package streamly
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+package ghcup
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+constraints: http-io-streams -brotli
+
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell

cabal.ghc8104.project.freeze

@@ -0,0 +1,261 @@
+active-repositories: hackage.haskell.org:merge
+constraints: any.Cabal ==3.2.1.0,
+             any.HUnit ==1.6.2.0,
+             any.IfElse ==0.85,
+             any.QuickCheck ==2.14.2,
+             QuickCheck -old-random +templatehaskell,
+             any.StateVar ==1.2.1,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
+             any.aeson ==1.5.6.0,
+             aeson -bytestring-builder -cffi -developer -fast,
+             any.aeson-pretty ==0.8.8,
+             aeson-pretty -lib-only,
+             any.alex ==3.2.6,
+             alex +small_base,
+             any.ansi-terminal ==0.11,
+             ansi-terminal -example,
+             any.ansi-wl-pprint ==0.6.9,
+             ansi-wl-pprint -example,
+             any.array ==0.5.4.0,
+             any.ascii-string ==1.0.1.4,
+             any.assoc ==1.0.2,
+             any.async ==2.2.3,
+             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
+             any.attoparsec ==0.13.2.5,
+             attoparsec -developer,
+             any.auto-update ==0.1.6,
+             any.base ==4.14.1.0,
+             any.base-compat ==0.11.2,
+             any.base-compat-batteries ==0.11.2,
+             any.base-orphans ==0.8.4,
+             any.base16-bytestring ==1.0.1.0,
+             any.base64-bytestring ==1.2.0.1,
+             any.bifunctors ==5.5.10,
+             bifunctors +semigroups +tagged,
+             any.binary ==0.8.8.0,
+             any.blaze-builder ==0.4.2.1,
+             any.bytestring ==0.10.12.0,
+             any.bz2 ==1.0.1.0,
+             bz2 -cross +with-bzlib,
+             any.c2hs ==0.28.7,
+             c2hs +base3 -regression,
+             any.call-stack ==0.3.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.5,
+             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.containers ==0.6.2.1,
+             any.contravariant ==1.5.3,
+             contravariant +semigroups +statevar +tagged,
+             any.cryptohash-sha256 ==0.11.102.0,
+             cryptohash-sha256 -exe +use-cbits,
+             any.data-default-class ==0.1.2.0,
+             any.data-fix ==0.3.1,
+             any.deepseq ==1.4.4.0,
+             any.deferred-folds ==0.9.17,
+             any.directory ==1.3.6.0,
+             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.fast-logger ==3.0.3,
+             any.filepath ==1.4.2.1,
+             any.focus ==1.0.2,
+             any.foldl ==1.4.11,
+             any.free ==5.1.6,
+             any.fusion-plugin-types ==0.1.0,
+             any.generic-arbitrary ==0.1.0,
+             any.generics-sop ==0.5.1.1,
+             any.ghc-boot-th ==8.10.4,
+             any.ghc-prim ==0.6.1,
+             ghcup -internal-downloader -tar -tui,
+             any.happy ==1.20.0,
+             any.hashable ==1.3.1.0,
+             hashable +integer-gmp,
+             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.heaps ==0.3.6.1,
+             any.hpath ==0.11.0,
+             any.hpath-directory ==0.14.1,
+             any.hpath-filepath ==0.10.4,
+             any.hpath-io ==0.14.1,
+             any.hpath-posix ==0.13.2,
+             any.hsc2hs ==0.68.7,
+             hsc2hs -in-ghc-tree,
+             any.hspec ==2.7.8,
+             any.hspec-core ==2.7.8,
+             any.hspec-discover ==2.7.8,
+             any.hspec-expectations ==0.8.2,
+             any.hspec-golden-aeson ==0.7.0.0,
+             any.indexed-profunctors ==0.1,
+             any.indexed-traversable ==0.1.1,
+             any.indexed-traversable-instances ==0.1,
+             any.integer-gmp ==1.0.3.0,
+             any.integer-logarithms ==1.0.3.1,
+             integer-logarithms -check-bounds +integer-gmp,
+             any.language-c ==0.8.3,
+             language-c -allwarnings +iecfpextension +separatesyb +usebytestrings,
+             any.libarchive ==3.0.2.1,
+             libarchive -cross -low-memory -system-libarchive,
+             any.libyaml ==0.1.2,
+             libyaml -no-unicode -system-libyaml,
+             any.lifted-base ==0.2.3.12,
+             any.list-t ==1.0.4,
+             any.lockfree-queue ==0.2.3.1,
+             lzma -static,
+             any.math-functions ==0.3.4.1,
+             math-functions +system-erf +system-expm1,
+             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.9,
+             any.mmorph ==1.1.5,
+             any.monad-control ==1.0.2.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.mwc-random ==0.15.0.1,
+             any.network ==3.1.2.1,
+             network -devel,
+             any.old-locale ==1.0.0.7,
+             any.old-time ==1.1.0.3,
+             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,
+             os-release -devel,
+             any.parallel ==3.2.2.0,
+             any.parsec ==3.1.14.0,
+             any.parser-combinators ==1.3.0,
+             parser-combinators -dev,
+             any.pretty ==1.1.3.6,
+             any.pretty-terminal ==0.1.0.0,
+             any.primitive ==0.7.1.0,
+             any.primitive-extras ==0.8.2,
+             any.primitive-unlifted ==0.1.3.0,
+             any.process ==1.6.9.0,
+             any.profunctors ==5.6.2,
+             any.quickcheck-arbitrary-adt ==0.3.1.0,
+             any.quickcheck-io ==0.2.0,
+             any.random ==1.2.0,
+             any.recursion-schemes ==5.2.2,
+             recursion-schemes +template-haskell,
+             any.regex-posix ==0.96.0.0,
+             regex-posix -_regex-posix-clib,
+             any.resourcet ==1.2.4.2,
+             any.rts ==1.0,
+             any.safe ==0.3.19,
+             any.safe-exceptions ==0.1.7.1,
+             any.scientific ==0.3.6.2,
+             scientific -bytestring-builder -integer-simple,
+             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.streamly ==0.7.3,
+             streamly -debug -dev -examples -examples-sdl -fusion-plugin -has-llvm -inspection -no-fusion -streamk,
+             any.streamly-bytestring ==0.1.2,
+             any.streamly-posix ==0.1.0.1,
+             any.strict ==0.4.0.1,
+             strict +assoc,
+             any.strict-base ==0.4.0.0,
+             any.string-interpolate ==0.3.1.0,
+             string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
+             any.syb ==0.7.2.1,
+             any.tagged ==0.8.6.1,
+             tagged +deepseq +transformers,
+             any.tasty ==1.3.1,
+             tasty +clock,
+             any.tasty-hunit ==0.10.0.3,
+             any.tasty-quickcheck ==0.10.1.2,
+             any.template-haskell ==2.16.0.0,
+             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-short ==0.1.3,
+             text-short -asserts,
+             any.tf-random ==0.5,
+             any.th-abstraction ==0.4.2.0,
+             any.th-compat ==0.1.1,
+             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.5,
+             time-compat -old-locale,
+             any.transformers ==0.5.6.2,
+             any.transformers-base ==0.4.5.2,
+             transformers-base +orphaninstances,
+             any.transformers-compat ==0.6.6,
+             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
+             any.typed-process ==0.2.6.0,
+             any.unbounded-delays ==0.1.1.1,
+             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.13.0,
+             unordered-containers -debug,
+             any.uri-bytestring ==0.3.3.0,
+             uri-bytestring -lib-werror,
+             any.utf8-string ==1.0.2,
+             any.uuid-types ==1.0.4,
+             any.vector ==0.12.2.0,
+             vector +boundschecks -internalchecks -unsafechecks -wall,
+             any.vector-algorithms ==0.8.0.4,
+             vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
+             any.versions ==4.0.3,
+             any.vty ==5.33,
+             any.wcwidth ==0.0.2,
+             wcwidth -cli +split-base,
+             any.word8 ==0.1.3,
+             any.yaml ==0.11.5.0,
+             yaml +no-examples +no-exe,
+             zlib -non-blocking-ffi -pkg-config -static
+index-state: hackage.haskell.org 2021-03-07T18:36:25Z

cabal.ghc884.project

@@ -0,0 +1,20 @@
+packages: ./ghcup.cabal
+
+with-compiler: ghc-8.8.4
+
+optional-packages: ./3rdparty/*/*.cabal
+
+optimization: 2
+
+package streamly
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+package ghcup
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+constraints: http-io-streams -brotli
+
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell

cabal.ghc884.project.freeze

@@ -0,0 +1,262 @@
+active-repositories: hackage.haskell.org:merge
+constraints: any.Cabal ==3.0.1.0,
+             any.HUnit ==1.6.2.0,
+             any.IfElse ==0.85,
+             any.QuickCheck ==2.14.2,
+             QuickCheck -old-random +templatehaskell,
+             any.StateVar ==1.2.1,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
+             any.aeson ==1.5.6.0,
+             aeson -bytestring-builder -cffi -developer -fast,
+             any.aeson-pretty ==0.8.8,
+             aeson-pretty -lib-only,
+             any.alex ==3.2.6,
+             alex +small_base,
+             any.ansi-terminal ==0.11,
+             ansi-terminal -example,
+             any.ansi-wl-pprint ==0.6.9,
+             ansi-wl-pprint -example,
+             any.array ==0.5.4.0,
+             any.ascii-string ==1.0.1.4,
+             any.assoc ==1.0.2,
+             any.async ==2.2.3,
+             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
+             any.attoparsec ==0.13.2.5,
+             attoparsec -developer,
+             any.auto-update ==0.1.6,
+             any.base ==4.13.0.0,
+             any.base-compat ==0.11.2,
+             any.base-compat-batteries ==0.11.2,
+             any.base-orphans ==0.8.4,
+             any.base16-bytestring ==1.0.1.0,
+             any.base64-bytestring ==1.2.0.1,
+             any.bifunctors ==5.5.10,
+             bifunctors +semigroups +tagged,
+             any.binary ==0.8.7.0,
+             any.blaze-builder ==0.4.2.1,
+             any.bytestring ==0.10.10.1,
+             any.bz2 ==1.0.1.0,
+             bz2 -cross +with-bzlib,
+             any.c2hs ==0.28.7,
+             c2hs +base3 -regression,
+             any.call-stack ==0.3.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.5,
+             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.containers ==0.6.2.1,
+             any.contravariant ==1.5.3,
+             contravariant +semigroups +statevar +tagged,
+             any.cryptohash-sha256 ==0.11.102.0,
+             cryptohash-sha256 -exe +use-cbits,
+             any.data-default-class ==0.1.2.0,
+             any.data-fix ==0.3.1,
+             any.deepseq ==1.4.4.0,
+             any.deferred-folds ==0.9.17,
+             any.directory ==1.3.6.0,
+             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,
+             exceptions +transformers-0-4,
+             any.fast-logger ==3.0.3,
+             any.filepath ==1.4.2.1,
+             any.focus ==1.0.2,
+             any.foldl ==1.4.11,
+             any.free ==5.1.6,
+             any.fusion-plugin-types ==0.1.0,
+             any.generic-arbitrary ==0.1.0,
+             any.generics-sop ==0.5.1.1,
+             any.ghc-boot-th ==8.8.4,
+             any.ghc-prim ==0.5.3,
+             ghcup -internal-downloader -tar -tui,
+             any.happy ==1.20.0,
+             any.hashable ==1.3.1.0,
+             hashable +integer-gmp,
+             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.heaps ==0.3.6.1,
+             any.hpath ==0.11.0,
+             any.hpath-directory ==0.14.1,
+             any.hpath-filepath ==0.10.4,
+             any.hpath-io ==0.14.1,
+             any.hpath-posix ==0.13.2,
+             any.hsc2hs ==0.68.7,
+             hsc2hs -in-ghc-tree,
+             any.hspec ==2.7.8,
+             any.hspec-core ==2.7.8,
+             any.hspec-discover ==2.7.8,
+             any.hspec-expectations ==0.8.2,
+             any.hspec-golden-aeson ==0.7.0.0,
+             any.indexed-profunctors ==0.1,
+             any.indexed-traversable ==0.1.1,
+             any.indexed-traversable-instances ==0.1,
+             any.integer-gmp ==1.0.2.0,
+             any.integer-logarithms ==1.0.3.1,
+             integer-logarithms -check-bounds +integer-gmp,
+             any.language-c ==0.8.3,
+             language-c -allwarnings +iecfpextension +separatesyb +usebytestrings,
+             any.libarchive ==3.0.2.1,
+             libarchive -cross -low-memory -system-libarchive,
+             any.libyaml ==0.1.2,
+             libyaml -no-unicode -system-libyaml,
+             any.lifted-base ==0.2.3.12,
+             any.list-t ==1.0.4,
+             any.lockfree-queue ==0.2.3.1,
+             lzma -static,
+             any.math-functions ==0.3.4.1,
+             math-functions +system-erf +system-expm1,
+             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.9,
+             any.mmorph ==1.1.5,
+             any.monad-control ==1.0.2.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.mwc-random ==0.15.0.1,
+             any.network ==3.1.2.1,
+             network -devel,
+             any.old-locale ==1.0.0.7,
+             any.old-time ==1.1.0.3,
+             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,
+             os-release -devel,
+             any.parallel ==3.2.2.0,
+             any.parsec ==3.1.14.0,
+             any.parser-combinators ==1.3.0,
+             parser-combinators -dev,
+             any.pretty ==1.1.3.6,
+             any.pretty-terminal ==0.1.0.0,
+             any.primitive ==0.7.1.0,
+             any.primitive-extras ==0.8.2,
+             any.primitive-unlifted ==0.1.3.0,
+             any.process ==1.6.9.0,
+             any.profunctors ==5.6.2,
+             any.quickcheck-arbitrary-adt ==0.3.1.0,
+             any.quickcheck-io ==0.2.0,
+             any.random ==1.2.0,
+             any.recursion-schemes ==5.2.2,
+             recursion-schemes +template-haskell,
+             any.regex-posix ==0.96.0.0,
+             regex-posix -_regex-posix-clib,
+             any.resourcet ==1.2.4.2,
+             any.rts ==1.0,
+             any.safe ==0.3.19,
+             any.safe-exceptions ==0.1.7.1,
+             any.scientific ==0.3.6.2,
+             scientific -bytestring-builder -integer-simple,
+             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.streamly ==0.7.3,
+             streamly -debug -dev -examples -examples-sdl -fusion-plugin -has-llvm -inspection -no-fusion -streamk,
+             any.streamly-bytestring ==0.1.2,
+             any.streamly-posix ==0.1.0.1,
+             any.strict ==0.4.0.1,
+             strict +assoc,
+             any.strict-base ==0.4.0.0,
+             any.string-interpolate ==0.3.1.0,
+             string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
+             any.syb ==0.7.2.1,
+             any.tagged ==0.8.6.1,
+             tagged +deepseq +transformers,
+             any.tasty ==1.3.1,
+             tasty +clock,
+             any.tasty-hunit ==0.10.0.3,
+             any.tasty-quickcheck ==0.10.1.2,
+             any.template-haskell ==2.15.0.0,
+             any.terminal-size ==0.3.2.1,
+             any.terminfo ==0.4.1.4,
+             any.text ==1.2.4.0,
+             any.text-conversions ==0.3.1,
+             any.text-short ==0.1.3,
+             text-short -asserts,
+             any.tf-random ==0.5,
+             any.th-abstraction ==0.4.2.0,
+             any.th-compat ==0.1.1,
+             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.5,
+             time-compat -old-locale,
+             any.transformers ==0.5.6.2,
+             any.transformers-base ==0.4.5.2,
+             transformers-base +orphaninstances,
+             any.transformers-compat ==0.6.6,
+             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
+             any.typed-process ==0.2.6.0,
+             any.unbounded-delays ==0.1.1.1,
+             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.13.0,
+             unordered-containers -debug,
+             any.uri-bytestring ==0.3.3.0,
+             uri-bytestring -lib-werror,
+             any.utf8-string ==1.0.2,
+             any.uuid-types ==1.0.4,
+             any.vector ==0.12.2.0,
+             vector +boundschecks -internalchecks -unsafechecks -wall,
+             any.vector-algorithms ==0.8.0.4,
+             vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
+             any.versions ==4.0.3,
+             any.vty ==5.33,
+             any.wcwidth ==0.0.2,
+             wcwidth -cli +split-base,
+             any.word8 ==0.1.3,
+             any.yaml ==0.11.5.0,
+             yaml +no-examples +no-exe,
+             zlib -non-blocking-ffi -pkg-config -static
+index-state: hackage.haskell.org 2021-03-07T18:36:25Z

cabal.project

@@ -2,15 +2,23 @@ packages: ./ghcup.cabal
 
 optimization: 2
 
-package streamly
-    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
-
 package ghcup
-    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+    tests: True
+    flags: +tui
 
-package tar-bytestring
-    ghc-options: -O2
+source-repository-package
+    type: git
+    location: https://github.com/Bodigrim/tar
+    tag: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
+
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/zip
+    tag: 6f02aa48622b8ba764d0cc0e6900f480a107aa96
 
 constraints: http-io-streams -brotli
 
-allow-newer: base
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell, language-c

cabal.project.freeze

@@ -0,0 +1,2 @@
+-- windows picks weird version
+constraints: any.hsc2hs ==0.68.7

config.yaml

@@ -0,0 +1,63 @@
+# Cache downloads in ~/.ghcup/cache
+cache: False
+# Skip tarball checksum verification
+no-verify: False
+# enable verbosity
+verbose: False
+# When to keep build directories
+keep-dirs: Errors  # Always | Never | Errors
+# Which downloader to use
+downloader: Curl   # Curl | Wget | Internal
+
+# TUI key bindings,
+# see https://hackage.haskell.org/package/vty-5.31/docs/Graphics-Vty-Input-Events.html#t:Key
+# for possible values.
+key-bindings:
+  up:
+    KUp: []
+  down:
+    KDown: []
+  quit:
+    KChar: 'q'
+  install:
+    KChar: 'i'
+  uninstall:
+    KChar: 'u'
+  set:
+    KChar: 's'
+  changelog:
+    KChar: 'c'
+  show-all:
+    KChar: 'a'
+  show-all-tools:
+    KChar: 't'
+
+# Where to get GHC/cabal/hls download info/versions from. For more detailed explanation
+# check the 'URLSource' type in the code.
+url-source:
+  ## Use the internal download uri, this is the default
+  GHCupURL: []
+
+  ## Example 1: Read download info from this location instead
+  ## Accepts file/http/https scheme
+  # OwnSource: "file:///home/jule/git/ghcup-hs/ghcup-0.0.3.yaml"
+
+  ## Example 2: Add custom tarballs to the default downloads, overwriting duplicate versions
+  # AddSource:
+    # Left:
+      # toolRequirements: {} # this is ignored
+      # ghcupDownloads:
+        # GHC:
+          # 9.10.2:
+            # viTags: []
+            # viArch:
+              # A_64:
+                # Linux_UnknownLinux:
+                  # unknown_versioning:
+                    # dlUri: https://downloads.haskell.org/~ghc/7.10.3/ghc-7.10.3-x86_64-deb8-linux.tar.bz2
+                    # dlSubdir: ghc-7.10.3
+                    # dlHash: 01cfbad8dff1e8b34a5fdca8caeaf843b56e36af919e29cd68870d2588563db5
+
+  ## Example 3: Add a custom download file to the default downloads, overwriting duplicate versions
+  # AddSource:
+    # Right: "file:///home/jule/git/ghcup-hs/ghcup-custom.yaml"

docker/build.sh

@@ -1,14 +0,0 @@
-#!/bin/sh
-
-set -ex
-
-cd /app
-
-cabal v2-update
-
-cabal v2-install \
-	--install-method=copy \
-	--overwrite-policy=always \
-	--installdir="/bin" \
-	--ghc-options='-optl-static'
-

ghcup.cabal

@@ -1,282 +1,54 @@
-cabal-version:      3.0
-name:               ghcup
-version:            0.1.1
-synopsis:           ghc toolchain installer as an exe/library
+cabal-version:   3.0
+name:            ghcup
+version:         0.1.15
+license:         LGPL-3.0-only
+license-file:    LICENSE
+copyright:       Julian Ospald 2020
+maintainer:      hasufell@posteo.de
+author:          Julian Ospald
+homepage:        https://gitlab.haskell.org/haskell/ghcup-hs
+bug-reports:     https://gitlab.haskell.org/haskell/ghcup-hs/issues
+synopsis:        ghc toolchain installer
 description:
   A rewrite of the shell script ghcup, for providing
   a more stable user experience and exposing an API.
 
-homepage:           https://github.com/hasufell/ghcup-hs
-bug-reports:        https://github.com/hasufell/ghcup-hs/issues
-license:            LGPL-3.0-only
-license-file:       LICENSE
-author:             Julian Ospald
-maintainer:         hasufell@posteo.de
-copyright:          Julian Ospald 2020
-category:           System
-build-type:         Simple
-extra-source-files: CHANGELOG.md
+category:        System
+build-type:      Simple
+extra-doc-files:
+  CHANGELOG.md
+  config.yaml
+  ghcup-0.0.4.yaml
+  HACKING.md
+  README.md
+  RELEASING.md
 
 source-repository head
   type:     git
-  location: https://github.com/hasufell/ghcup-hs
+  location: https://gitlab.haskell.org/haskell/ghcup-hs.git
+
+flag tui
+  description:
+    Build the brick powered tui (ghcup tui). This is disabled on windows.
 
-flag Curl
-  description: Use curl instead of http-io-streams for download
   default:     False
   manual:      True
 
-common HsOpenSSL
-  build-depends: HsOpenSSL >=0.11.4.18
+flag internal-downloader
+  description:
+    Compile the internal downloader, which links against OpenSSL. This is disabled on windows.
 
-common aeson
-  build-depends: aeson >=1.4
+  default:     False
+  manual:      True
 
-common aeson-pretty
-  build-depends: aeson-pretty >=0.8.8
+flag tar
+  description:
+    Use tar-bytestring instead of libarchive.
 
-common ascii-string
-  build-depends: ascii-string >=1.0
-
-common async
-  build-depends: async >=0.8
-
-common attoparsec
-  build-depends: attoparsec >=0.13
-
-common base
-  build-depends: base >=4.12 && <5
-
-common base16-bytestring
-  build-depends: base16-bytestring >= 0.1.1.6
-
-common binary
-  build-depends: binary >=0.8.6.0
-
-common bytestring
-  build-depends: bytestring >=0.10
-
-common bz2
-  build-depends: bz2 >=0.5.0.5
-
-common case-insensitive
-  build-depends: case-insensitive >=1.2.1.0
-
-common concurrent-output
-  build-depends: concurrent-output >=1.10.11
-
-common containers
-  build-depends: containers >=0.6
-
-common cryptohash-sha256
-  build-depends: cryptohash-sha256 >= 0.11.101.0
-
-common generics-sop
-  build-depends: generics-sop >=0.5
-
-common haskus-utils-types
-  build-depends: haskus-utils-types >=1.5
-
-common haskus-utils-variant
-  build-depends: haskus-utils-variant >=3.0
-
-common hpath
-  build-depends: hpath >=0.11
-
-common hpath-directory
-  build-depends: hpath-directory >=0.13.3
-
-common hpath-filepath
-  build-depends: hpath-filepath >=0.10.3
-
-common hpath-io
-  build-depends: hpath-io >=0.13.1
-
-common hpath-posix
-  build-depends: hpath-posix >=0.13.2
-
-common http-io-streams
-  build-depends: http-io-streams >=0.1.2.0
-
-common io-streams
-  build-depends: io-streams >=1.5
-
-common language-bash
-  build-depends: language-bash >=0.9
-
-common lzma
-  build-depends: lzma >=0.0.0.3
-
-common megaparsec
-  build-depends: megaparsec >=8.0.0
-
-common monad-logger
-  build-depends: monad-logger >=0.3.31
-
-common mtl
-  build-depends: mtl >=2.2
-
-common optics
-  build-depends: optics >=0.2
-
-common optics-vl
-  build-depends: optics-vl >=0.2
-
-common optparse-applicative
-  build-depends: optparse-applicative >=0.15.1.0
-
-common parsec
-  build-depends: parsec >=3.1
-
-common pretty-terminal
-  build-depends: pretty-terminal >=0.1.0.0
-
-common regex-posix
-  build-depends: regex-posix >=0.96
-
-common resourcet
-  build-depends: resourcet >=1.2.2
-
-common safe
-  build-depends: safe >=0.3.18
-
-common safe-exceptions
-  build-depends: safe-exceptions >=0.1
-
-common streamly
-  build-depends: streamly >=0.7.1
-
-common streamly-posix
-  build-depends: streamly-posix >=0.1.0.0
-
-common streamly-bytestring
-  build-depends: streamly-bytestring >=0.1.2
-
-common strict-base
-  build-depends: strict-base >=0.4
-
-common string-interpolate
-  build-depends: string-interpolate >=0.2.0.0
-
-common table-layout
-  build-depends: table-layout >=0.8
-
-common tar-bytestring
-  build-depends: tar-bytestring >=0.6.3.1
-
-common template-haskell
-  build-depends: template-haskell >=2.7
-
-common terminal-progress-bar
-  build-depends: terminal-progress-bar >=0.4.1
-
-common text
-  build-depends: text >=1.2
-
-common time
-  build-depends: time >=1.9.3
-
-common transformers
-  build-depends: transformers >=0.5
-
-common unix
-  build-depends: unix >=2.7
-
-common unix-bytestring
-  build-depends: unix-bytestring >=0.3
-
-common uri-bytestring
-  build-depends: uri-bytestring >=0.3.2.2
-
-common utf8-string
-  build-depends: utf8-string >=1.0
-
-common vector
-  build-depends: vector >=0.12
-
-common versions
-  build-depends: versions >=3.5
-
-common waargonaut
-  build-depends: waargonaut >=0.8
-
-common word8
-  build-depends: word8 >=0.1.3
-
-common zlib
-  build-depends: zlib >=0.6.2.1
-
-common config
-  default-language:   Haskell2010
-  ghc-options:
-    -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns
-    -fwarn-incomplete-record-updates -threaded
-
-  default-extensions:
-    LambdaCase
-    MultiWayIf
-    PackageImports
-    RecordWildCards
-    ScopedTypeVariables
-    Strict
-    StrictData
-    TupleSections
+  default:     False
+  manual:      True
 
 library
-  import:
-    config
-    , base
-    , base16-bytestring
-    , aeson
-    , ascii-string
-    , async
-    , attoparsec
-    , binary
-    , bytestring
-    , bz2
-    , case-insensitive
-    , concurrent-output
-    , containers
-    , cryptohash-sha256
-    , generics-sop
-    , haskus-utils-types
-    , haskus-utils-variant
-    , hpath
-    , hpath-directory
-    , hpath-filepath
-    , hpath-io
-    , hpath-posix
-    , language-bash
-    , lzma
-    , monad-logger
-    , mtl
-    , optics
-    , optics-vl
-    , parsec
-    , pretty-terminal
-    , regex-posix
-    , resourcet
-    , safe
-    , safe-exceptions
-    , streamly
-    , streamly-posix
-    , streamly-bytestring
-    , strict-base
-    , string-interpolate
-    , tar-bytestring
-    , template-haskell
-    , text
-    , time
-    , transformers
-    , unix
-    , unix-bytestring
-    , uri-bytestring
-    , utf8-string
-    , vector
-    , versions
-    , word8
-    , zlib
-
   exposed-modules:
     GHCup
     GHCup.Download
@@ -288,101 +60,281 @@ library
     GHCup.Types.JSON
     GHCup.Types.Optics
     GHCup.Utils
-    GHCup.Utils.Bash
     GHCup.Utils.Dirs
     GHCup.Utils.File
+    GHCup.Utils.File.Common
     GHCup.Utils.Logger
+    GHCup.Utils.MegaParsec
     GHCup.Utils.Prelude
     GHCup.Utils.String.QQ
     GHCup.Utils.Version.QQ
     GHCup.Version
 
-  -- other-modules:
-  -- other-extensions:
-  hs-source-dirs:  lib
+  hs-source-dirs:     lib
+  other-modules:      Paths_ghcup
+  autogen-modules:    Paths_ghcup
+  default-language:   Haskell2010
+  default-extensions:
+    DeriveGeneric
+    LambdaCase
+    MultiWayIf
+    NamedFieldPuns
+    PackageImports
+    QuasiQuotes
+    RecordWildCards
+    ScopedTypeVariables
+    Strict
+    StrictData
+    TupleSections
+    TypeApplications
+    TypeFamilies
+    ViewPatterns
 
-  if !flag(curl)
-    import:
-      , HsOpenSSL
-      , http-io-streams
-      , io-streams
-      , terminal-progress-bar
+  ghc-options:
+    -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns
+    -fwarn-incomplete-record-updates
+
+  build-depends:
+    , aeson                 >=1.4        && <1.6
+    , async                 >=0.8        && <2.3
+    , base                  >=4.13       && <5
+    , base16-bytestring     >=0.1.1.6    && <1.1
+    , binary                ^>=0.8.6.0
+    , bytestring            ^>=0.10
+    , case-insensitive      ^>=1.2.1.0
+    , casing                ^>=0.1.4.1
+    , concurrent-output     ^>=1.10.11
+    , containers            ^>=0.6
+    , cryptohash-sha256     ^>=0.11.101.0
+    , 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
+    , lzma-static           ^>=5.2.5.2
+    , megaparsec            >=8.0.0      && <9.1
+    , monad-logger          ^>=0.3.31
+    , mtl                   ^>=2.2
+    , optics                >=0.2        && <0.5
+    , 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
+    , resourcet             ^>=1.2.2
+    , safe                  ^>=0.3.18
+    , 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
+    , time                  ^>=1.9.3
+    , transformers          ^>=0.5
+    , 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
+    , word8                 ^>=0.1.3
+    , yaml                  ^>=0.11.4.0
+    , zip                   ^>=1.7.0
+    , zlib                  ^>=0.6.2.2
+
+  if (flag(internal-downloader) && !os(windows))
     exposed-modules: GHCup.Download.IOStreams
+    cpp-options:     -DINTERNAL_DOWNLOADER
+    build-depends:
+      , HsOpenSSL              >=0.11.4.18
+      , http-io-streams        >=0.1.2.0
+      , io-streams             >=1.5.2.1
+      , terminal-progress-bar  >=0.4.1
+
+  if (flag(tar) || os(windows))
+    cpp-options:   -DTAR
+    build-depends: tar
+
   else
-    cpp-options:     -DCURL
+    build-depends: libarchive ^>=3.0.0.0
+
+  if os(windows)
+    cpp-options:   -DIS_WINDOWS
+    other-modules: GHCup.Utils.File.Windows
+    build-depends:
+      , bzlib
+      , process  ^>=1.6.11.0
+      , retry    ^>=0.8.1.2
+      , Win32    ^>=2.10
+
+  else
+    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
+
+  if (flag(tui) && !os(windows))
+    cpp-options:   -DBRICK
+    build-depends: vty >=5.28.2 && <5.34
 
 executable ghcup
-  import:
-    config
-    , base
-    , bytestring
-    , containers
-    , haskus-utils-variant
-    , hpath
-    , hpath-io
-    , megaparsec
-    , monad-logger
-    , mtl
-    , optparse-applicative
-    , pretty-terminal
-    , resourcet
-    , string-interpolate
-    , table-layout
-    , text
-    , uri-bytestring
-    , utf8-string
-    , versions
+  main-is:            Main.hs
+  hs-source-dirs:     app/ghcup
+  default-language:   Haskell2010
+  default-extensions:
+    LambdaCase
+    MultiWayIf
+    NamedFieldPuns
+    PackageImports
+    RecordWildCards
+    ScopedTypeVariables
+    Strict
+    StrictData
+    TupleSections
 
-  --
-  main-is:          Main.hs
+  ghc-options:
+    -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns
+    -fwarn-incomplete-record-updates -threaded
 
-  -- other-modules:
-  -- other-extensions:
-  build-depends:    ghcup
-  hs-source-dirs:   app/ghcup
-  default-language: Haskell2010
+  build-depends:
+    , base                  >=4.13     && <5
+    , bytestring            ^>=0.10
+    , containers            ^>=0.6
+    , filepath              ^>=1.4.2.1
+    , ghcup
+    , haskus-utils-variant  >=3.0      && <3.2
+    , 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
+    , pretty-terminal       ^>=0.1.0.0
+    , 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
+
+  if flag(internal-downloader)
+    cpp-options: -DINTERNAL_DOWNLOADER
+
+  if (flag(tui) && !os(windows))
+    cpp-options:   -DBRICK
+    other-modules: BrickMain
+    build-depends:
+      , brick         >=0.5    && <0.62
+      , transformers  ^>=0.5
+      , vector        ^>=0.12
+      , vty           >=5.28.2 && <5.34
+
+  if os(windows)
+    cpp-options: -DIS_WINDOWS
+
+  if (flag(tar) || os(windows))
+    cpp-options: -DTAR
+
+  else
+    build-depends: libarchive ^>=3.0.0.0
 
 executable ghcup-gen
-  import:
-    config
-    , base
-    , aeson
-    , aeson-pretty
-    , bytestring
-    , containers
-    , haskus-utils-variant
-    , hpath
-    , monad-logger
-    , mtl
-    , optics
-    , optparse-applicative
-    , pretty-terminal
-    , resourcet
-    , safe-exceptions
-    , string-interpolate
-    , table-layout
-    , text
-    , transformers
-    , uri-bytestring
-    , utf8-string
-    , versions
+  main-is:            Main.hs
+  hs-source-dirs:     app/ghcup-gen
+  other-modules:      Validate
+  default-language:   Haskell2010
+  default-extensions:
+    DeriveGeneric
+    LambdaCase
+    MultiWayIf
+    NamedFieldPuns
+    PackageImports
+    QuasiQuotes
+    RecordWildCards
+    ScopedTypeVariables
+    Strict
+    StrictData
+    TupleSections
+    TypeApplications
+    TypeFamilies
+    ViewPatterns
 
-  --
-  main-is:          Main.hs
-  other-modules:
-    GHCupDownloads
-    GHCupInfo
-    ToolRequirements
-    Validate
+  ghc-options:
+    -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns
+    -fwarn-incomplete-record-updates -threaded
 
-  -- other-extensions:
-  build-depends:    ghcup
-  hs-source-dirs:   app/ghcup-gen
-  default-language: Haskell2010
+  build-depends:
+    , base                  >=4.13     && <5
+    , bytestring            ^>=0.10
+    , containers            ^>=0.6
+    , filepath              ^>=1.4.2.1
+    , ghcup
+    , haskus-utils-variant  >=3.0      && <3.2
+    , monad-logger          ^>=0.3.31
+    , mtl                   ^>=2.2
+    , optics                >=0.2      && <0.5
+    , optparse-applicative  >=0.15.1.0 && <0.17
+    , pretty                ^>=1.1.3.1
+    , pretty-terminal       ^>=0.1.0.0
+    , 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
+    , yaml                  ^>=0.11.4.0
+
+  if (flag(tar) || os(windows))
+    cpp-options:   -DTAR
+    build-depends: tar
+
+  else
+    build-depends: libarchive ^>=3.0.0.0
 
 test-suite ghcup-test
-  default-language: Haskell2010
-  type:             exitcode-stdio-1.0
-  hs-source-dirs:   test
-  main-is:          MyLibTest.hs
-  build-depends:    base >=4.12.0.0
+  type:               exitcode-stdio-1.0
+  main-is:            Main.hs
+  hs-source-dirs:     test
+  other-modules:
+    GHCup.ArbitraryTypes
+    GHCup.Types.JSONSpec
+    Spec
+
+  default-language:   Haskell2010
+  default-extensions:
+    LambdaCase
+    MultiWayIf
+    PackageImports
+    RecordWildCards
+    ScopedTypeVariables
+    TupleSections
+
+  ghc-options:
+    -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns
+    -fwarn-incomplete-record-updates
+
+  build-depends:
+    , base                      >=4.13    && <5
+    , bytestring                ^>=0.10
+    , containers                ^>=0.6
+    , generic-arbitrary         ^>=0.1.0
+    , ghcup
+    , hspec                     ^>=2.7.10
+    , hspec-golden-aeson        ^>=0.9
+    , QuickCheck                ^>=2.14.1
+    , quickcheck-arbitrary-adt  ^>=0.3.1.0
+    , text                      ^>=1.2.4.0
+    , uri-bytestring            ^>=0.3.2.2
+    , versions                  ^>=4.0.1

hie.yaml

@@ -0,0 +1,10 @@
+cradle:
+  cabal:
+  - component: "ghcup:lib:ghcup"
+    path: ./lib
+  - component: "ghcup:exe:ghcup"
+    path: ./app/ghcup
+  - component: "ghcup:exe:ghcup-gen"
+    path: "./app/ghcup-gen"
+  - component: "ghcup:test:ghcup-test"
+    path: ./test

lib/GHCup/Download.hs

@@ -9,9 +9,26 @@
 {-# LANGUAGE TypeFamilies          #-}
 
 
+{-|
+Module      : GHCup.Download
+Description : Downloading
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+
+Module for handling all download related functions.
+
+Generally we support downloading via:
+
+  - curl (default)
+  - wget
+  - internal downloader (only when compiled)
+-}
 module GHCup.Download where
 
-#if !defined(CURL)
+#if defined(INTERNAL_DOWNLOADER)
 import           GHCup.Download.IOStreams
 import           GHCup.Download.Utils
 #endif
@@ -19,7 +36,7 @@ import           GHCup.Errors
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Types.Optics
-import           GHCup.Utils
+import           GHCup.Utils.Dirs
 import           GHCup.Utils.File
 import           GHCup.Utils.Prelude
 import           GHCup.Version
@@ -35,42 +52,45 @@ import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
                                          hiding ( throwM )
 import           Data.Aeson
-#if !defined(CURL)
+import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
+#if defined(INTERNAL_DOWNLOADER)
 import           Data.CaseInsensitive           ( CI )
 #endif
+import           Data.List.Extra
 import           Data.Maybe
 import           Data.String.Interpolate
 import           Data.Time.Clock
 import           Data.Time.Clock.POSIX
-#if !defined(CURL)
+#if defined(INTERNAL_DOWNLOADER)
 import           Data.Time.Format
 #endif
 import           Data.Versions
+import           Data.Word8
 import           GHC.IO.Exception
-import           HPath
-import           HPath.IO                      as HIO
 import           Haskus.Utils.Variant.Excepts
 import           Optics
 import           Prelude                 hiding ( abs
                                                 , readFile
                                                 , writeFile
                                                 )
+import           System.Directory
+import           System.Environment
+import           System.FilePath
 import           System.IO.Error
 import           URI.ByteString
 
 import qualified Crypto.Hash.SHA256            as SHA256
+import qualified Data.ByteString               as B
 import qualified Data.ByteString.Base16        as B16
 import qualified Data.ByteString.Lazy          as L
-#if !defined(CURL)
-import qualified Data.CaseInsensitive          as CI
 import qualified Data.Map.Strict               as M
-import qualified Data.Text                     as T
+#if defined(INTERNAL_DOWNLOADER)
+import qualified Data.CaseInsensitive          as CI
 #endif
+import qualified Data.Text                     as T
 import qualified Data.Text.Encoding            as E
-import qualified System.Posix.Files.ByteString as PF
-import qualified System.Posix.RawFilePath.Directory
-                                               as RD
+import qualified Data.Yaml                     as Y
 
 
 
@@ -82,30 +102,80 @@ import qualified System.Posix.RawFilePath.Directory
     ------------------
 
 
--- | Downloads the download information! But only if we need to ;P
-getDownloads :: ( FromJSONKey Tool
-                , FromJSONKey Version
-                , FromJSON VersionInfo
-                , MonadIO m
-                , MonadCatch m
-                , MonadLogger m
-                , MonadThrow m
-                , MonadFail m
-                )
-             => URLSource
-             -> Excepts '[JSONError , DownloadFailed] m GHCupInfo
-getDownloads urlSource = do
-  lift $ $(logDebug) [i|Receiving download info from: #{urlSource}|]
-  case urlSource of
-    GHCupURL -> do
-      bs <- reThrowAll DownloadFailed $ smartDl ghcupURL
-      lE' JSONDecodeError $ eitherDecode' bs
-    (OwnSource url) -> do
-      bs <- reThrowAll DownloadFailed $ downloadBS url
-      lE' JSONDecodeError $ eitherDecode' bs
-    (OwnSpec av) -> pure $ av
 
- where
+-- | Downloads the download information! But only if we need to ;P
+getDownloadsF :: ( FromJSONKey Tool
+                 , FromJSONKey Version
+                 , FromJSON VersionInfo
+                 , MonadIO m
+                 , MonadCatch m
+                 , MonadLogger m
+                 , MonadThrow m
+                 , MonadFail m
+                 )
+              => Settings
+              -> Dirs
+              -> Excepts
+                   '[JSONError , DownloadFailed , FileDoesNotExistError]
+                   m
+                   GHCupInfo
+getDownloadsF settings@Settings{ urlSource } dirs = do
+  case urlSource of
+    GHCupURL -> liftE $ getBase dirs settings
+    (OwnSource url) -> do
+      bs <- reThrowAll DownloadFailed $ downloadBS (downloader settings) url
+      lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)
+    (OwnSpec av) -> pure av
+    (AddSource (Left ext)) -> do
+      base <- liftE $ getBase dirs settings
+      pure (mergeGhcupInfo base ext)
+    (AddSource (Right uri)) -> do
+      base <- liftE $ getBase dirs settings
+      bsExt <- reThrowAll DownloadFailed $ downloadBS (downloader settings) uri
+      ext <- lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bsExt)
+      pure (mergeGhcupInfo base ext)
+
+    where
+
+  mergeGhcupInfo :: GHCupInfo -- ^ base to merge with
+                 -> GHCupInfo -- ^ extension overwriting the base
+                 -> GHCupInfo
+  mergeGhcupInfo (GHCupInfo tr base base2) (GHCupInfo _ ext ext2) =
+    let newDownloads = M.mapWithKey (\k a -> case M.lookup k ext of
+                                        Just a' -> M.union a' a
+                                        Nothing -> a
+                                    ) base
+        newGlobalTools = M.union base2 ext2
+    in GHCupInfo tr newDownloads newGlobalTools
+
+
+readFromCache :: (MonadIO m, MonadCatch m, MonadLogger m)
+              => Dirs
+              -> Excepts '[JSONError, FileDoesNotExistError] m GHCupInfo
+readFromCache Dirs {..} = do
+  lift $ $(logWarn)
+    [i|Could not get download info, trying cached version (this may not be recent!)|]
+  let path = view pathL' ghcupURL
+  let yaml_file = cacheDir </> (T.unpack . decUTF8Safe . urlBaseName $ path)
+  bs        <-
+    handleIO' NoSuchThing
+              (\_ -> throwE $ FileDoesNotExistError yaml_file)
+    $ liftIO
+    $ L.readFile yaml_file
+  lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)
+
+
+getBase :: (MonadFail m, MonadIO m, MonadCatch m, MonadLogger m)
+        => Dirs
+        -> Settings
+        -> Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
+getBase dirs@Dirs{..} Settings{ downloader }  =
+  handleIO (\_ -> readFromCache dirs)
+  $ catchE @_ @'[JSONError, FileDoesNotExistError]
+      (\(DownloadFailed _) -> readFromCache dirs)
+  (reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed (smartDl ghcupURL)
+    >>= (liftE . lE' @_ @_ @'[JSONError] JSONDecodeError . first show . Y.decodeEither' . L.toStrict))
+    where
   -- 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
   -- last 5 minutes, just reuse it.
@@ -116,7 +186,11 @@ getDownloads urlSource = do
   --
   -- Always save the local file with the mod time of the remote file.
   smartDl :: forall m1
-           . (MonadCatch m1, MonadIO m1, MonadFail m1, MonadLogger m1)
+           . ( MonadCatch m1
+             , MonadIO m1
+             , MonadFail m1
+             , MonadLogger m1
+             )
           => URI
           -> Excepts
                '[ FileDoesNotExistError
@@ -131,48 +205,52 @@ getDownloads urlSource = do
                L.ByteString
   smartDl uri' = do
     let path = view pathL' uri'
-    cacheDir  <- liftIO $ ghcupCacheDir
-    json_file <- (cacheDir </>) <$> urlBaseName path
+    let json_file = cacheDir </> (T.unpack . decUTF8Safe . urlBaseName $ path)
     e         <- liftIO $ doesFileExist json_file
     if e
       then do
-        accessTime <-
-          PF.accessTimeHiRes
-            <$> (liftIO $ PF.getFileStatus (toFilePath json_file))
-        currentTime <- liftIO $ getPOSIXTime
+        accessTime <- liftIO $ getAccessTime json_file
+        currentTime <- liftIO getCurrentTime
 
         -- access time won't work on most linuxes, but we can try regardless
-        if (currentTime - accessTime) > 300
+        if (utcTimeToPOSIXSeconds currentTime - utcTimeToPOSIXSeconds accessTime) > 300
           then do -- no access in last 5 minutes, re-check upstream mod time
             getModTime >>= \case
               Just modTime -> do
                 fileMod <- liftIO $ getModificationTime json_file
                 if modTime > fileMod
-                  then do
-                    bs <- liftE $ downloadBS uri'
-                    liftIO $ writeFileWithModTime modTime json_file bs
-                    pure bs
-                  else liftIO $ readFile json_file
+                  then dlWithMod modTime json_file
+                  else liftIO $ L.readFile json_file
               Nothing -> do
                 lift $ $(logDebug) [i|Unable to get/parse Last-Modified header|]
-                liftIO $ deleteFile json_file
-                liftE $ downloadBS uri'
+                dlWithoutMod json_file
           else -- access in less than 5 minutes, re-use file
-               liftIO $ readFile json_file
+               liftIO $ L.readFile json_file
       else do
-        liftIO $ createDirIfMissing newDirPerms cacheDir
+        liftIO $ createDirRecursive' cacheDir
         getModTime >>= \case
-          Just modTime -> do
-            bs <- liftE $ downloadBS uri'
-            liftIO $ writeFileWithModTime modTime json_file bs
-            pure bs
+          Just modTime -> dlWithMod modTime json_file
           Nothing -> do
+            -- although we don't know last-modified, we still save
+            -- it to a file, so we might use it in offline mode
             lift $ $(logDebug) [i|Unable to get/parse Last-Modified header|]
-            liftE $ downloadBS uri'
+            dlWithoutMod json_file
 
    where
+    dlWithMod modTime json_file = do
+      bs <- liftE $ downloadBS downloader uri'
+      liftIO $ writeFileWithModTime modTime json_file bs
+      pure bs
+    dlWithoutMod json_file = do
+      bs <- liftE $ downloadBS downloader uri'
+      liftIO $ hideError doesNotExistErrorType $ rmFile json_file
+      liftIO $ L.writeFile json_file bs
+      liftIO $ setModificationTime json_file (posixSecondsToUTCTime (fromIntegral @Int 0))
+      pure bs
+
+
     getModTime = do
-#if defined(CURL)
+#if !defined(INTERNAL_DOWNLOADER)
       pure Nothing
 #else
       headers <-
@@ -192,15 +270,14 @@ getDownloads urlSource = do
       True
       defaultTimeLocale
       "%a, %d %b %Y %H:%M:%S %Z"
-      (T.unpack . E.decodeUtf8 $ h)
+      (T.unpack . decUTF8Safe $ h)
 
 #endif
 
-  writeFileWithModTime :: UTCTime -> Path Abs -> L.ByteString -> IO ()
+  writeFileWithModTime :: UTCTime -> FilePath -> L.ByteString -> IO ()
   writeFileWithModTime utctime path content = do
-    let mod_time = utcTimeToPOSIXSeconds utctime
-    writeFileL path (Just newFilePerms) content
-    setModificationTimeHiRes path mod_time
+    L.writeFile path content
+    setModificationTime path utctime
 
 
 getDownloadInfo :: Tool
@@ -212,7 +289,11 @@ getDownloadInfo :: Tool
 getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
   (Left NoDownload)
   Right
-  (with_distro <|> without_distro_ver <|> without_distro)
+  (case p of
+    -- non-musl won't work on alpine
+    Linux Alpine -> with_distro <|> without_distro_ver
+    _            -> with_distro <|> without_distro_ver <|> without_distro
+  )
 
  where
   with_distro        = distro_preview id id
@@ -220,7 +301,18 @@ getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
   without_distro     = distro_preview (set _Linux UnknownLinux) (const Nothing)
 
   distro_preview f g =
-    preview (ix t % ix v % viArch % ix a % ix (f p) % ix (g mv)) dls
+    let platformVersionSpec =
+          preview (ix t % ix v % viArch % ix a % ix (f p)) dls
+        mv' = g mv
+    in  fmap snd
+          .   find
+                (\(mverRange, _) -> maybe
+                  (isNothing mv')
+                  (\range -> maybe False (`versionRange` range) mv')
+                  mverRange
+                )
+          .   M.toList
+          =<< platformVersionSpec
 
 
 -- | Tries to download from the given http or https url
@@ -231,16 +323,16 @@ getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
 --
 -- The file must not exist.
 download :: ( MonadMask m
-            , MonadReader Settings m
             , MonadThrow m
             , MonadLogger m
             , MonadIO m
             )
-         => DownloadInfo
-         -> Path Abs          -- ^ destination dir
-         -> Maybe (Path Rel)  -- ^ optional filename
-         -> Excepts '[DigestError , DownloadFailed] m (Path Abs)
-download dli dest mfn
+         => Settings
+         -> DownloadInfo
+         -> FilePath          -- ^ destination dir
+         -> Maybe FilePath    -- ^ optional filename
+         -> Excepts '[DigestError , DownloadFailed] m FilePath
+download settings@Settings{ downloader } dli dest mfn
   | scheme == "https" = dl
   | scheme == "http"  = dl
   | scheme == "file"  = cp
@@ -250,41 +342,48 @@ download dli dest mfn
   scheme = view (dlUri % uriSchemeL' % schemeBSL') dli
   cp     = do
     -- destination dir must exist
-    liftIO $ hideError AlreadyExists $ createDirRecursive newDirPerms dest
-    destFile <- getDestFile
-    fromFile <- parseAbs path
-    liftIO $ copyFile fromFile destFile Strict
+    liftIO $ createDirRecursive' dest
+    let destFile = getDestFile
+    let fromFile = T.unpack . decUTF8Safe $ path
+    liftIO $ copyFile fromFile destFile
     pure destFile
   dl = do
-    let uri' = E.decodeUtf8 (serializeURIRef' (view dlUri dli))
+    let uri' = decUTF8Safe (serializeURIRef' (view dlUri dli))
     lift $ $(logInfo) [i|downloading: #{uri'}|]
 
     -- destination dir must exist
-    liftIO $ hideError AlreadyExists $ createDirRecursive newDirPerms dest
-    destFile <- getDestFile
+    liftIO $ createDirRecursive' dest
+    let destFile = getDestFile
 
     -- download
     flip onException
-         (liftIO $ hideError doesNotExistErrorType $ deleteFile destFile)
+         (liftIO $ hideError doesNotExistErrorType $ rmFile destFile)
      $ catchAllE @_ @'[ProcessError, DownloadFailed, UnsupportedScheme]
           (\e ->
-            (liftIO $ hideError doesNotExistErrorType $ deleteFile destFile)
+            liftIO (hideError doesNotExistErrorType $ rmFile destFile)
               >> (throwE . DownloadFailed $ e)
           ) $ do
-#if defined(CURL)
-              liftE $ lEM @_ @'[ProcessError] $ liftIO $ exec "curl" True
-                ["-fL", "-o", toFilePath destFile , serializeURIRef' $ view dlUri dli] Nothing Nothing
-#else
-              (https, host, fullPath, port) <- liftE $ uriToQuadruple (view dlUri dli)
-              liftE $ downloadToFile https host fullPath port destFile
+              case downloader of
+                Curl -> do
+                  o' <- liftIO getCurlOpts
+                  liftE $ lEM @_ @'[ProcessError] $ exec "curl" 
+                    (o' ++ ["-fL", "-o", destFile, (T.unpack . decUTF8Safe) $ serializeURIRef' $ view dlUri dli]) Nothing Nothing
+                Wget -> do
+                  o' <- liftIO getWgetOpts
+                  liftE $ lEM @_ @'[ProcessError] $ exec "wget" 
+                    (o' ++ ["-O", destFile , (T.unpack . decUTF8Safe) $ serializeURIRef' $ view dlUri dli]) Nothing Nothing
+#if defined(INTERNAL_DOWNLOADER)
+                Internal -> do
+                  (https, host, fullPath, port) <- liftE $ uriToQuadruple (view dlUri dli)
+                  liftE $ downloadToFile https host fullPath port destFile
 #endif
 
-    liftE $ checkDigest dli destFile
+    liftE $ checkDigest settings dli destFile
     pure destFile
 
   -- Manage to find a file we can write the body into.
-  getDestFile :: MonadThrow m => m (Path Abs)
-  getDestFile = maybe (urlBaseName path <&> (dest </>)) (pure . (dest </>)) mfn
+  getDestFile :: FilePath
+  getDestFile = maybe (dest </> T.unpack (decUTF8Safe (urlBaseName path))) (dest </>) mfn
 
   path        = view (dlUri % pathL') dli
 
@@ -296,27 +395,41 @@ downloadCached :: ( MonadMask m
                   , MonadThrow m
                   , MonadLogger m
                   , MonadIO m
-                  , MonadReader Settings m
+                  , MonadUnliftIO m
                   )
-               => DownloadInfo
-               -> Maybe (Path Rel)  -- ^ optional filename
-               -> Excepts '[DigestError , DownloadFailed] m (Path Abs)
-downloadCached dli mfn = do
-  cache <- lift getCache
+               => Settings
+               -> Dirs
+               -> DownloadInfo
+               -> Maybe FilePath  -- ^ optional filename
+               -> Excepts '[DigestError , DownloadFailed] m FilePath
+downloadCached settings@Settings{ cache } dirs dli mfn = do
   case cache of
-    True -> do
-      cachedir <- liftIO $ ghcupCacheDir
-      fn       <- maybe (urlBaseName $ view (dlUri % pathL') dli) pure mfn
-      let cachfile = cachedir </> fn
-      fileExists <- liftIO $ doesFileExist cachfile
-      if
-        | fileExists -> do
-          liftE $ checkDigest dli cachfile
-          pure $ cachfile
-        | otherwise -> liftE $ download dli cachedir mfn
+    True -> downloadCached' settings dirs dli mfn
     False -> do
       tmp <- lift withGHCupTmpDir
-      liftE $ download dli tmp mfn
+      liftE $ download settings dli tmp mfn
+
+
+downloadCached' :: ( MonadMask m
+                   , MonadThrow m
+                   , MonadLogger m
+                   , MonadIO m
+                   , MonadUnliftIO m
+                   )
+                => Settings
+                -> Dirs
+                -> DownloadInfo
+                -> Maybe FilePath  -- ^ optional filename
+                -> Excepts '[DigestError , DownloadFailed] m FilePath
+downloadCached' settings Dirs{..} dli mfn = do
+  let fn = fromMaybe ((T.unpack . decUTF8Safe) $ urlBaseName $ view (dlUri % pathL') dli) mfn
+  let cachfile = cacheDir </> fn
+  fileExists <- liftIO $ doesFileExist cachfile
+  if
+    | fileExists -> do
+      liftE $ checkDigest settings dli cachfile
+      pure cachfile
+    | otherwise -> liftE $ download settings dli cacheDir mfn
 
 
 
@@ -329,8 +442,9 @@ downloadCached dli mfn = do
 
 
 -- | This is used for downloading the JSON.
-downloadBS :: (MonadCatch m, MonadIO m)
-           => URI
+downloadBS :: (MonadCatch m, MonadIO m, MonadLogger m)
+           => Downloader
+           -> URI
            -> Excepts
                 '[ FileDoesNotExistError
                  , HTTPStatusError
@@ -342,46 +456,83 @@ downloadBS :: (MonadCatch m, MonadIO m)
                  ]
                 m
                 L.ByteString
-downloadBS uri'
+downloadBS downloader uri'
   | scheme == "https"
   = dl True
   | scheme == "http"
   = dl False
   | scheme == "file"
-  = liftIOException doesNotExistErrorType (FileDoesNotExistError path)
-    $ (liftIO $ RD.readFile path)
+  = liftIOException doesNotExistErrorType (FileDoesNotExistError $ T.unpack $ decUTF8Safe path)
+    (liftIO $ L.readFile (T.unpack $ decUTF8Safe path))
   | otherwise
   = throwE UnsupportedScheme
 
  where
   scheme = view (uriSchemeL' % schemeBSL') uri'
   path   = view pathL' uri'
-#if defined(CURL)
-  dl _ = do
-    let exe = [rel|curl|]
-        args = ["-sSfL", serializeURIRef' uri']
-    liftIO (executeOut exe args Nothing) >>= \case
-      CapturedProcess ExitSuccess stdout _ -> do
-        pure $ L.fromStrict stdout
-      CapturedProcess (ExitFailure i') _ _ -> throwE $ NonZeroExit i' (toFilePath exe) args
-#else
+#if defined(INTERNAL_DOWNLOADER)
   dl https = do
-    (_, host', fullPath', port') <- liftE $ uriToQuadruple uri'
-    liftE $ downloadBS' https host' fullPath' port'
+#else
+  dl _ = do
+#endif
+    lift $ $(logDebug) [i|downloading: #{serializeURIRef' uri'}|]
+    case downloader of
+      Curl -> do
+        o' <- liftIO getCurlOpts
+        let exe = "curl"
+            args = o' ++ ["-sSfL", T.unpack $ decUTF8Safe $ serializeURIRef' uri']
+        lift (executeOut exe args Nothing) >>= \case
+          CapturedProcess ExitSuccess stdout _ -> do
+            pure stdout
+          CapturedProcess (ExitFailure i') _ _ -> throwE $ NonZeroExit i' exe args
+      Wget -> do
+        o' <- liftIO getWgetOpts
+        let exe = "wget"
+            args = o' ++ ["-qO-", T.unpack $ decUTF8Safe $ serializeURIRef' uri']
+        lift (executeOut exe args Nothing) >>= \case
+          CapturedProcess ExitSuccess stdout _ -> do
+            pure stdout
+          CapturedProcess (ExitFailure i') _ _ -> throwE $ NonZeroExit i' exe args
+#if defined(INTERNAL_DOWNLOADER)
+      Internal -> do
+        (_, host', fullPath', port') <- liftE $ uriToQuadruple uri'
+        liftE $ downloadBS' https host' fullPath' port'
 #endif
 
 
-checkDigest :: (MonadIO m, MonadLogger m, MonadReader Settings m)
-            => DownloadInfo
-            -> Path Abs
+checkDigest :: (MonadIO m, MonadThrow m, MonadLogger m)
+            => Settings
+            -> DownloadInfo
+            -> FilePath
             -> Excepts '[DigestError] m ()
-checkDigest dli file = do
-  verify <- lift ask <&> (not . noVerify)
+checkDigest Settings{ noVerify } dli file = do
+  let verify = not noVerify
   when verify $ do
-    let p' = toFilePath file
+    let p' = takeFileName file
     lift $ $(logInfo) [i|verifying digest of: #{p'}|]
-    c <- liftIO $ readFile file
-    let cDigest = E.decodeUtf8 . B16.encode . SHA256.hashlazy $ c
-        eDigest = view dlHash dli
+    c <- liftIO $ L.readFile file
+    cDigest <- throwEither . E.decodeUtf8' . B16.encode . SHA256.hashlazy $ c
+    let eDigest = view dlHash dli
     when ((cDigest /= eDigest) && verify) $ throwE (DigestError cDigest eDigest)
 
+
+-- | Get additional curl args from env. This is an undocumented option.
+getCurlOpts :: IO [String]
+getCurlOpts =
+  lookupEnv "GHCUP_CURL_OPTS" >>= \case
+    Just r  -> pure $ splitOn " " r
+    Nothing -> pure []
+
+
+-- | Get additional wget args from env. This is an undocumented option.
+getWgetOpts :: IO [String]
+getWgetOpts =
+  lookupEnv "GHCUP_WGET_OPTS" >>= \case
+    Just r  -> pure $ splitOn " " r
+    Nothing -> pure []
+
+
+urlBaseName :: ByteString  -- ^ the url path (without scheme and host)
+            -> ByteString
+urlBaseName = snd . B.breakEnd (== _slash) . urlDecode False
+

lib/GHCup/Download/IOStreams.hs

@@ -1,10 +1,6 @@
 {-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE DeriveGeneric         #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE OverloadedStrings     #-}
-{-# LANGUAGE QuasiQuotes           #-}
-{-# LANGUAGE TemplateHaskell       #-}
-{-# LANGUAGE TypeApplications      #-}
 {-# LANGUAGE TypeFamilies          #-}
 
 
@@ -28,8 +24,6 @@ import           Data.CaseInsensitive           ( CI )
 import           Data.IORef
 import           Data.Maybe
 import           Data.Text.Read
-import           HPath
-import           HPath.IO                      as HIO
 import           Haskus.Utils.Variant.Excepts
 import           Network.Http.Client     hiding ( URL )
 import           Optics
@@ -37,17 +31,13 @@ import           Prelude                 hiding ( abs
                                                 , readFile
                                                 , writeFile
                                                 )
-import "unix"    System.Posix.IO.ByteString
-                                         hiding ( fdWrite )
-import "unix-bytestring" System.Posix.IO.ByteString
-                                                ( fdWrite )
 import           System.ProgressBar
+import           System.IO
 import           URI.ByteString
 
 import qualified Data.ByteString               as BS
 import qualified Data.ByteString.Lazy          as L
 import qualified Data.Map.Strict               as M
-import qualified Data.Text.Encoding            as E
 import qualified System.IO.Streams             as Streams
 
 
@@ -73,7 +63,7 @@ downloadBS' :: MonadIO m
                   , TooManyRedirs
                   ]
                  m
-                 (L.ByteString)
+                 L.ByteString
 downloadBS' https host path port = do
   bref <- liftIO $ newIORef (mempty :: Builder)
   let stepper bs = modifyIORef bref (<> byteString bs)
@@ -86,12 +76,12 @@ downloadToFile :: (MonadMask m, MonadIO m)
                -> ByteString       -- ^ host (e.g. "www.example.com")
                -> ByteString       -- ^ path (e.g. "/my/file") including query
                -> Maybe Int        -- ^ optional port (e.g. 3000)
-               -> Path Abs         -- ^ destination file to create and write to
+               -> FilePath         -- ^ destination file to create and write to
                -> Excepts '[DownloadFailed] m ()
 downloadToFile https host fullPath port destFile = do
-  fd <- liftIO $ createRegularFileFd newFilePerms destFile
-  let stepper = fdWrite fd
-  flip finally (liftIO $ closeFd fd)
+  fd <- liftIO $ openFile destFile WriteMode
+  let stepper = BS.hPut fd
+  flip finally (liftIO $ hClose fd)
     $ reThrowAll DownloadFailed $ downloadInternal True https host fullPath port stepper
 
 
@@ -133,7 +123,7 @@ downloadInternal = go (5 :: Int)
           if
             | scode >= 200 && scode < 300 -> downloadStream r i' >> pure Nothing
             | scode >= 300 && scode < 400 -> case getHeader r "Location" of
-              Just r' -> pure $ Just $ r'
+              Just r' -> pure $ Just r'
               Nothing -> throwE NoLocationHeader
             | otherwise -> throwE $ HTTPStatusError scode
         )
@@ -146,13 +136,13 @@ downloadInternal = go (5 :: Int)
 
     downloadStream r i' = do
       let size = case getHeader r "Content-Length" of
-            Just x' -> case decimal $ E.decodeUtf8 x' of
+            Just x' -> case decimal $ decUTF8Safe x' of
               Left  _       -> 0
               Right (r', _) -> r'
             Nothing -> 0
 
       mpb <- if progressBar
-        then Just <$> (liftIO $ newProgressBar defStyle 10 (Progress 0 size ()))
+        then Just <$> liftIO (newProgressBar defStyle 10 (Progress 0 size ()))
         else pure Nothing
 
       outStream <- liftIO $ Streams.makeOutputStream
@@ -225,9 +215,9 @@ headInternal = go (5 :: Int)
           if
             | scode >= 200 && scode < 300 -> do
               let headers = getHeaderMap r
-              pure $ Right $ headers
+              pure $ Right headers
             | scode >= 300 && scode < 400 -> case getHeader r "Location" of
-              Just r' -> pure $ Left $ r'
+              Just r' -> pure $ Left r'
               Nothing -> throwE NoLocationHeader
             | otherwise -> throwE $ HTTPStatusError scode
         )
@@ -244,7 +234,7 @@ withConnection' :: Bool
                 -> Maybe Int
                 -> (Connection -> IO a)
                 -> IO a
-withConnection' https host port action = bracket acquire closeConnection action
+withConnection' https host port = bracket acquire closeConnection
 
  where
   acquire = case https of

lib/GHCup/Download/Utils.hs

@@ -1,10 +1,6 @@
 {-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE DeriveGeneric         #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE OverloadedStrings     #-}
-{-# LANGUAGE QuasiQuotes           #-}
-{-# LANGUAGE TemplateHaskell       #-}
-{-# LANGUAGE TypeApplications      #-}
 {-# LANGUAGE TypeFamilies          #-}
 
 
@@ -55,7 +51,7 @@ uriToQuadruple URI {..} = do
   let queryBS =
         BS.intercalate "&"
           . fmap (\(x, y) -> encodeQuery x <> "=" <> encodeQuery y)
-          $ (queryPairs uriQuery)
+          $ queryPairs uriQuery
       port =
         preview (_Just % authorityPortL' % _Just % portNumberL') uriAuthority
       fullpath = if BS.null queryBS then uriPath else uriPath <> "?" <> queryBS

lib/GHCup/Errors.hs

@@ -1,18 +1,39 @@
+{-# OPTIONS_GHC -Wno-orphans #-}
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds               #-}
 {-# LANGUAGE ExistentialQuantification #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE DataKinds #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE TypeOperators           #-}
+{-# LANGUAGE FlexibleInstances           #-}
 
+{-|
+Module      : GHCup.Errors
+Description : GHCup error types
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+-}
 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.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           Haskus.Utils.Variant
-import           HPath
+import           Text.PrettyPrint
+import           Text.PrettyPrint.HughesPJClass
+import           URI.ByteString
 
 
 
@@ -26,93 +47,213 @@ import           HPath
 data NoCompatiblePlatform = NoCompatiblePlatform String -- the platform we got
   deriving Show
 
+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.
 data NoDownload = NoDownload
   deriving Show
 
+instance Pretty NoDownload where
+  pPrint NoDownload =
+    text "Unable to find a download for the requested version/distro."
+
+-- | No update available or necessary.
+data NoUpdate = NoUpdate
+  deriving Show
+
+instance Pretty NoUpdate where
+  pPrint NoUpdate = text "No update available or necessary."
+
 -- | The Architecture is unknown and unsupported.
 data NoCompatibleArch = NoCompatibleArch String
   deriving Show
 
+instance Pretty NoCompatibleArch where
+  pPrint (NoCompatibleArch arch) =
+    text ("The Architecture is unknown or unsupported. Got: " ++ arch)
+
 -- | Unable to figure out the distribution of the host.
 data DistroNotFound = DistroNotFound
   deriving Show
 
+instance Pretty DistroNotFound where
+  pPrint DistroNotFound =
+    text "Unable to figure out the distribution of the host."
+
 -- | The archive format is unknown. We don't know how to extract it.
-data UnknownArchive = UnknownArchive ByteString
+data UnknownArchive = UnknownArchive FilePath
   deriving Show
 
+instance Pretty UnknownArchive where
+  pPrint (UnknownArchive file) =
+    text [i|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
   deriving Show
 
+instance Pretty UnsupportedScheme where
+  pPrint UnsupportedScheme = text "The scheme is not supported (such as ftp)."
+
 -- | Unable to copy a file.
 data CopyError = CopyError String
   deriving Show
 
+instance Pretty CopyError where
+  pPrint (CopyError reason) =
+    text ("Unable to copy a file. Reason was: " ++ reason)
+
 -- | Unable to find a tag of a tool.
 data TagNotFound = TagNotFound Tag Tool
   deriving Show
 
+instance Pretty TagNotFound where
+  pPrint (TagNotFound tag tool) =
+    text "Unable to find tag" <+> pPrint tag <+> text [i|of tool "#{tool}"|]
+
+-- | Unable to find the next version of a tool (the one after the currently
+-- set one).
+data NextVerNotFound = NextVerNotFound Tool
+  deriving Show
+
+instance Pretty NextVerNotFound where
+  pPrint (NextVerNotFound tool) =
+    text [i|Unable to find next (the one after the currently set one) version of tool "#{tool}"|]
+
 -- | The tool (such as GHC) is already installed with that version.
 data AlreadyInstalled = AlreadyInstalled Tool Version
   deriving Show
 
+instance Pretty AlreadyInstalled where
+  pPrint (AlreadyInstalled tool ver') =
+    text [i|#{tool}-#{prettyShow ver'} is already installed|]
+
 -- | The tool is not installed. Some operations rely on a tool
 -- to be installed (such as setting the current GHC version).
-data NotInstalled = NotInstalled Tool Version
+data NotInstalled = NotInstalled Tool GHCTargetVersion
   deriving Show
 
+instance Pretty NotInstalled where
+  pPrint (NotInstalled tool ver) =
+    text [i|The version "#{prettyShow ver}" of the tool "#{tool}" is not installed.|]
+
 -- | An executable was expected to be in PATH, but was not found.
-data NotFoundInPATH = NotFoundInPATH (Path Rel)
+data NotFoundInPATH = NotFoundInPATH FilePath
   deriving Show
 
+instance Pretty NotFoundInPATH where
+  pPrint (NotFoundInPATH exe) =
+    text [i|The exe "#{exe}" was not found in PATH.|]
+
 -- | JSON decoding failed.
 data JSONError = JSONDecodeError String
   deriving Show
 
+instance Pretty JSONError where
+  pPrint (JSONDecodeError err) =
+    text [i|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).
-data FileDoesNotExistError = FileDoesNotExistError ByteString
+data FileDoesNotExistError = FileDoesNotExistError FilePath
   deriving Show
 
+instance Pretty FileDoesNotExistError where
+  pPrint (FileDoesNotExistError file) =
+    text [i|File "#{file}" does not exist.|]
+
+data TarDirDoesNotExist = TarDirDoesNotExist TarDir
+  deriving Show
+
+instance Pretty TarDirDoesNotExist where
+  pPrint (TarDirDoesNotExist dir) =
+    text "Tar directory does not exist:" <+> pPrint dir
+
 -- | File digest verification failed.
 data DigestError = DigestError Text Text
   deriving Show
 
+instance Pretty DigestError where
+  pPrint (DigestError currentDigest expectedDigest) =
+    text [i|Digest error: expected "#{expectedDigest}", but got "#{currentDigest}"|]
+
 -- | Unexpected HTTP status.
 data HTTPStatusError = HTTPStatusError Int
   deriving Show
 
+instance Pretty HTTPStatusError where
+  pPrint (HTTPStatusError status) =
+    text [i|Unexpected HTTP status: #{status}|]
+
 -- | The 'Location' header was expected during a 3xx redirect, but not found.
 data NoLocationHeader = NoLocationHeader
   deriving Show
 
+instance Pretty NoLocationHeader where
+  pPrint NoLocationHeader =
+    text [i|The 'Location' header was expected during a 3xx redirect, but not found.|]
+
 -- | Too many redirects.
 data TooManyRedirs = TooManyRedirs
   deriving Show
 
+instance Pretty TooManyRedirs where
+  pPrint TooManyRedirs =
+    text [i|Too many redirections.|]
+
 -- | A patch could not be applied.
 data PatchFailed = PatchFailed
   deriving Show
 
+instance Pretty PatchFailed where
+  pPrint PatchFailed =
+    text [i|A patch could not be applied.|]
+
 -- | The tool requirements could not be found.
 data NoToolRequirements = NoToolRequirements
   deriving Show
 
+instance Pretty NoToolRequirements where
+  pPrint NoToolRequirements =
+    text [i|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}|]
+
+data NoToolVersionSet = NoToolVersionSet Tool
+  deriving Show
+
+instance Pretty NoToolVersionSet where
+  pPrint (NoToolVersionSet tool) =
+    text [i|No version is set for tool "#{tool}".|]
+
 
     -------------------------
     --[ High-level errors ]--
     -------------------------
 
 -- | A download failed. The underlying error is encapsulated.
-data DownloadFailed = forall es . Show (V es) => DownloadFailed (V es)
+data DownloadFailed = forall x xs . (Show x, Show (V xs), Pretty x, Pretty (V xs)) => DownloadFailed (V (x ': xs))
+
+instance Pretty DownloadFailed where
+  pPrint (DownloadFailed reason) =
+    text "Download failed:" <+> pPrint reason
 
 deriving instance Show DownloadFailed
 
 
 -- | A build failed.
-data BuildFailed = forall es . Show (V es) => BuildFailed (Path Abs) (V es)
+data BuildFailed = forall es . Show (V es) => BuildFailed FilePath (V es)
+
+instance Pretty BuildFailed where
+  pPrint (BuildFailed path reason) =
+    text [i|BuildFailed failed in dir "#{path}": #{reason}|]
 
 deriving instance Show BuildFailed
 
@@ -120,6 +261,10 @@ deriving instance Show BuildFailed
 -- | Setting the current GHC version failed.
 data GHCupSetError = forall es . Show (V es) => GHCupSetError (V es)
 
+instance Pretty GHCupSetError where
+  pPrint (GHCupSetError reason) =
+    text [i|Setting the current GHC version failed: #{reason}|]
+
 deriving instance Show GHCupSetError
 
 
@@ -132,4 +277,75 @@ deriving instance Show GHCupSetError
 data ParseError = ParseError String
   deriving Show
 
+instance Pretty ParseError where
+  pPrint (ParseError reason) =
+    text [i|Parsing failed: #{reason}|]
+
 instance Exception ParseError
+
+
+data UnexpectedListLength = UnexpectedListLength String
+  deriving Show
+
+instance Pretty UnexpectedListLength where
+  pPrint (UnexpectedListLength reason) =
+    text [i|List length unexpected: #{reason}|]
+
+instance Exception UnexpectedListLength
+
+
+
+    ------------------------
+    --[ orphan instances ]--
+    ------------------------
+
+instance Pretty (V '[]) where
+   {-# INLINABLE pPrint #-}
+   pPrint _ = undefined
+
+instance
+   ( Pretty x
+   , Pretty (V xs)
+   ) => Pretty (V (x ': xs))
+   where
+      pPrint v = case popVariantHead v of
+         Right x -> pPrint x
+         Left xs -> pPrint xs
+
+instance Pretty URIParseError where
+  pPrint (MalformedScheme reason) =
+    text [i|Failed to parse URI. Malformed scheme: #{reason}|]
+  pPrint MalformedUserInfo =
+    text [i|Failed to parse URI. Malformed user info.|]
+  pPrint MalformedQuery =
+    text [i|Failed to parse URI. Malformed query.|]
+  pPrint MalformedFragment =
+    text [i|Failed to parse URI. Malformed fragment.|]
+  pPrint MalformedHost =
+    text [i|Failed to parse URI. Malformed host.|]
+  pPrint MalformedPort =
+    text [i|Failed to parse URI. Malformed port.|]
+  pPrint MalformedPath =
+    text [i|Failed to parse URI. Malformed path.|]
+  pPrint (OtherError err) =
+    text [i|Failed to parse URI: #{err}|]
+
+#if !defined(TAR)
+instance Pretty ArchiveResult where
+  pPrint ArchiveFatal = text "Archive result: fatal"
+  pPrint ArchiveFailed = text "Archive result: failed"
+  pPrint ArchiveWarn = text "Archive result: warning"
+  pPrint ArchiveRetry = text "Archive result: retry"
+  pPrint ArchiveOk = text "Archive result: Ok"
+  pPrint ArchiveEOF = text "Archive result: EOF"
+#else
+instance Pretty Tar.FormatError where
+  pPrint Tar.TruncatedArchive = text "Truncated archive"
+  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

@@ -6,13 +6,21 @@
 {-# LANGUAGE TemplateHaskell       #-}
 
 
+{-|
+Module      : GHCup.Plaform
+Description : Retrieving platform information
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+-}
 module GHCup.Platform where
 
 
 import           GHCup.Errors
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
-import           GHCup.Utils.Bash
 import           GHCup.Utils.File
 import           GHCup.Utils.Prelude
 import           GHCup.Utils.String.QQ
@@ -28,18 +36,20 @@ import           Data.Maybe
 import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
-import           HPath
-import           HPath.IO
 import           Haskus.Utils.Variant.Excepts
 import           Prelude                 hiding ( abs
                                                 , readFile
                                                 , writeFile
                                                 )
 import           System.Info
+import           System.Directory
+import           System.OsRelease
 import           Text.Regex.Posix
 
 import qualified Data.Text                     as T
-import qualified Data.Text.Encoding            as E
+import qualified Data.Text.IO                  as T
+
+
 
     --------------------------
     --[ Platform detection ]--
@@ -47,12 +57,9 @@ import qualified Data.Text.Encoding            as E
 
 
 -- | Get the full platform request, consisting of architecture, distro, ...
-platformRequest :: (MonadLogger m, MonadCatch m, MonadIO m)
+platformRequest :: (Alternative m, MonadFail m, MonadLogger m, MonadCatch m, MonadIO m)
                 => Excepts
-                     '[ NoCompatiblePlatform
-                      , NoCompatibleArch
-                      , DistroNotFound
-                      ]
+                     '[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound]
                      m
                      PlatformRequest
 platformRequest = do
@@ -63,15 +70,21 @@ platformRequest = do
 
 getArchitecture :: Either NoCompatibleArch Architecture
 getArchitecture = case arch of
-  "x86_64" -> Right A_64
-  "i386"   -> Right A_32
-  what     -> Left (NoCompatibleArch what)
+  "x86_64"      -> Right A_64
+  "i386"        -> Right A_32
+  "powerpc"     -> Right A_PowerPC
+  "powerpc64"   -> Right A_PowerPC64
+  "powerpc64le" -> Right A_PowerPC64
+  "sparc"       -> Right A_Sparc
+  "sparc64"     -> Right A_Sparc64
+  "arm"         -> Right A_ARM
+  "aarch64"     -> Right A_ARM64
+  what          -> Left (NoCompatibleArch what)
 
 
-
-getPlatform :: (MonadLogger m, MonadCatch m, MonadIO m)
+getPlatform :: (Alternative m, MonadLogger m, MonadCatch m, MonadIO m, MonadFail m)
             => Excepts
-                 '[NoCompatiblePlatform , DistroNotFound]
+                 '[NoCompatiblePlatform, DistroNotFound]
                  m
                  PlatformResult
 getPlatform = do
@@ -81,40 +94,39 @@ getPlatform = do
       pure $ PlatformResult { _platform = Linux distro, _distroVersion = ver }
     "darwin" -> do
       ver <-
-        ( either (const Nothing) Just
+        either (const Nothing) Just
           . versioning
+          -- TODO: maybe do this somewhere else
           . getMajorVersion
-          . E.decodeUtf8
-          )
-          <$> getDarwinVersion
+          . decUTF8Safe'
+        <$> getDarwinVersion
       pure $ PlatformResult { _platform = Darwin, _distroVersion = ver }
     "freebsd" -> do
       ver <-
-        (either (const Nothing) Just . versioning . E.decodeUtf8)
+        either (const Nothing) Just . versioning . decUTF8Safe'
           <$> getFreeBSDVersion
       pure $ PlatformResult { _platform = FreeBSD, _distroVersion = ver }
+    "mingw32" -> pure PlatformResult { _platform = Windows, _distroVersion = Nothing }
     what -> throwE $ NoCompatiblePlatform what
   lift $ $(logDebug) [i|Identified Platform as: #{pfr}|]
   pure pfr
  where
   getMajorVersion = T.intercalate "." . take 2 . T.split (== '.')
-  getFreeBSDVersion =
-    liftIO $ fmap _stdOut $ executeOut [rel|freebsd-version|] [] Nothing
-  getDarwinVersion = liftIO $ fmap _stdOut $ executeOut [rel|sw_vers|]
+  getFreeBSDVersion = lift $ fmap _stdOut $ executeOut "freebsd-version" [] Nothing
+  getDarwinVersion = lift $ fmap _stdOut $ executeOut "sw_vers"
                                                         ["-productVersion"]
                                                         Nothing
 
 
-getLinuxDistro :: (MonadCatch m, MonadIO m)
+getLinuxDistro :: (Alternative m, MonadCatch m, MonadIO m, MonadFail m)
                => Excepts '[DistroNotFound] m (LinuxDistro, Maybe Versioning)
 getLinuxDistro = do
   -- TODO: don't do alternative on IO, because it hides bugs
-  (name, ver) <- handleIO (\_ -> throwE DistroNotFound) $ liftIO $ asum
-    [ try_os_release
+  (name, ver) <- handleIO (\_ -> throwE DistroNotFound) $ lift $ asum
+    [ liftIO try_os_release
     , try_lsb_release_cmd
-    , try_lsb_release
-    , try_redhat_release
-    , try_debian_version
+    , liftIO try_redhat_release
+    , liftIO try_debian_version
     ]
   let parsedVer = ver >>= either (const Nothing) Just . versioning
       distro    = if
@@ -137,43 +149,34 @@ getLinuxDistro = do
    where
     regex x = makeRegexOpts compIgnoreCase execBlank ([s|\<|] ++ x ++ [s|\>|])
 
-  os_release :: Path Abs
-  os_release = [abs|/etc/os-release|]
-  lsb_release :: Path Abs
-  lsb_release = [abs|/etc/lsb-release|]
-  lsb_release_cmd :: Path Rel
-  lsb_release_cmd = [rel|lsb-release|]
-  redhat_release :: Path Abs
-  redhat_release = [abs|/etc/redhat-release|]
-  debian_version :: Path Abs
-  debian_version = [abs|/etc/debian_version|]
+  lsb_release_cmd :: FilePath
+  lsb_release_cmd = "lsb-release"
+  redhat_release :: FilePath
+  redhat_release = "/etc/redhat-release"
+  debian_version :: FilePath
+  debian_version = "/etc/debian_version"
 
   try_os_release :: IO (Text, Maybe Text)
   try_os_release = do
-    (Just name) <- getAssignmentValueFor os_release "NAME"
-    ver         <- getAssignmentValueFor os_release "VERSION_ID"
-    pure (T.pack name, fmap T.pack ver)
+    Just OsRelease{ name = name, version_id = version_id } <-
+      fmap osRelease <$> parseOsRelease
+    pure (T.pack name, fmap T.pack version_id)
 
-  try_lsb_release_cmd :: IO (Text, Maybe Text)
+  try_lsb_release_cmd :: (MonadFail m, MonadIO m)
+                      => m (Text, Maybe Text)
   try_lsb_release_cmd = do
-    (Just _) <- findExecutable lsb_release_cmd
+    (Just _) <- liftIO $ findExecutable lsb_release_cmd
     name     <- fmap _stdOut $ executeOut lsb_release_cmd ["-si"] Nothing
     ver      <- fmap _stdOut $ executeOut lsb_release_cmd ["-sr"] Nothing
-    pure (E.decodeUtf8 name, Just $ E.decodeUtf8 ver)
-
-  try_lsb_release :: IO (Text, Maybe Text)
-  try_lsb_release = do
-    (Just name) <- getAssignmentValueFor lsb_release "DISTRIB_ID"
-    ver         <- getAssignmentValueFor lsb_release "DISTRIB_RELEASE"
-    pure (T.pack name, fmap T.pack ver)
+    pure (decUTF8Safe' name, Just $ decUTF8Safe' ver)
 
   try_redhat_release :: IO (Text, Maybe Text)
   try_redhat_release = do
-    t <- fmap lBS2sT $ readFile redhat_release
+    t <- T.readFile redhat_release
     let nameRegex n =
           makeRegexOpts compIgnoreCase
                         execBlank
-                        (([s|\<|] <> fS n <> [s|\>|] :: ByteString)) :: Regex
+                        ([s|\<|] <> fS n <> [s|\>|] :: ByteString) :: Regex
     let verRegex =
           makeRegexOpts compIgnoreCase
                         execBlank
@@ -191,5 +194,5 @@ getLinuxDistro = do
 
   try_debian_version :: IO (Text, Maybe Text)
   try_debian_version = do
-    ver <- readFile debian_version
-    pure (T.pack "debian", Just $ lBS2sT ver)
+    ver <- T.readFile debian_version
+    pure (T.pack "debian", Just ver)

lib/GHCup/Requirements.hs

@@ -1,12 +1,23 @@
 {-# LANGUAGE OverloadedStrings #-}
 
+{-|
+Module      : GHCup.Requirements
+Description : Requirements utilities
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+-}
 module GHCup.Requirements where
 
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Types.Optics
+import           GHCup.Version
 
 import           Control.Applicative
+import           Data.List                      ( find )
 import           Data.Maybe
 import           Optics
 import           Prelude                 hiding ( abs
@@ -14,6 +25,7 @@ import           Prelude                 hiding ( abs
                                                 , writeFile
                                                 )
 
+import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 
 
@@ -24,22 +36,32 @@ getCommonRequirements :: PlatformResult
                       -> ToolRequirements
                       -> Maybe Requirements
 getCommonRequirements pr tr =
-  preview (ix GHC % ix Nothing % ix (_platform pr) % ix (_distroVersion pr)) tr
-    <|> preview (ix GHC % ix Nothing % ix (_platform pr) % ix Nothing) tr
-    <|> preview
-          ( ix GHC
-          % ix Nothing
-          % ix (set _Linux UnknownLinux $ _platform pr)
-          % ix Nothing
-          )
-          tr
+  with_distro <|> without_distro_ver <|> without_distro
+ where
+  with_distro        = distro_preview _platform _distroVersion
+  without_distro_ver = distro_preview _platform (const Nothing)
+  without_distro     = distro_preview (set _Linux UnknownLinux . _platform) (const Nothing)
+
+  distro_preview f g =
+    let platformVersionSpec =
+          preview (ix GHC % ix Nothing % ix (f pr)) tr
+        mv' = g pr
+    in  fmap snd
+          .   find
+                (\(mverRange, _) -> maybe
+                  (isNothing mv')
+                  (\range -> maybe False (`versionRange` range) mv')
+                  mverRange
+                )
+          .   M.toList
+          =<< platformVersionSpec
 
 
 prettyRequirements :: Requirements -> T.Text
 prettyRequirements Requirements {..} =
   let d = if not . null $ _distroPKGs
         then
-          "\n  Install the following distro packages: "
+          "\n  Please install the following distro packages: "
             <> T.intercalate " " _distroPKGs
         else ""
       n = if not . T.null $ _notes then "\n  Note: " <> _notes else ""

lib/GHCup/Types.hs

@@ -1,16 +1,52 @@
-{-# LANGUAGE DeriveGeneric #-}
+{-# OPTIONS_GHC -Wno-orphans #-}
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DeriveGeneric     #-}
+{-# LANGUAGE OverloadedStrings #-}
 
-module GHCup.Types where
+{-|
+Module      : GHCup.Types
+Description : GHCup types
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+-}
+module GHCup.Types
+  ( module GHCup.Types
+#if defined(BRICK)
+  , Key(..)
+#endif
+  )
+  where
 
+import           Control.Applicative
+import           Control.Monad.Logger
 import           Data.Map.Strict                ( Map )
+import           Data.List.NonEmpty             ( NonEmpty (..) )
 import           Data.Text                      ( Text )
 import           Data.Versions
-import           HPath
+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
 
 
+#if !defined(BRICK)
+data Key = KEsc  | KChar Char | KBS | KEnter
+         | KLeft | KRight | KUp | KDown
+         | KUpLeft | KUpRight | KDownLeft | KDownRight | KCenter
+         | KFun Int | KBackTab | KPrtScr | KPause | KIns
+         | KHome | KPageUp | KDel | KEnd | KPageDown | KBegin | KMenu
+    deriving (Eq,Show,Read,Ord,GHC.Generic)
+#endif
+
 
     --------------------
     --[ GHCInfo Tree ]--
@@ -20,6 +56,7 @@ import qualified GHC.Generics                  as GHC
 data GHCupInfo = GHCupInfo
   { _toolRequirements :: ToolRequirements
   , _ghcupDownloads   :: GHCupDownloads
+  , _globalTools      :: Map GlobalTool DownloadInfo
   }
   deriving (Show, GHC.Generic)
 
@@ -33,7 +70,7 @@ data GHCupInfo = GHCupInfo
 type ToolRequirements = Map Tool ToolReqVersionSpec
 type ToolReqVersionSpec = Map (Maybe Version) PlatformReqSpec
 type PlatformReqSpec = Map Platform PlatformReqVersionSpec
-type PlatformReqVersionSpec = Map (Maybe Versioning) Requirements
+type PlatformReqVersionSpec = Map (Maybe VersionRange) Requirements
 
 
 data Requirements = Requirements
@@ -57,44 +94,102 @@ type GHCupDownloads = Map Tool ToolVersionSpec
 type ToolVersionSpec = Map Version VersionInfo
 type ArchitectureSpec = Map Architecture PlatformSpec
 type PlatformSpec = Map Platform PlatformVersionSpec
-type PlatformVersionSpec = Map (Maybe Versioning) DownloadInfo
+type PlatformVersionSpec = Map (Maybe VersionRange) DownloadInfo
 
 
 -- | An installable tool.
 data Tool = GHC
           | Cabal
           | GHCup
-  deriving (Eq, GHC.Generic, Ord, Show)
+          | HLS
+          | Stack
+  deriving (Eq, GHC.Generic, Ord, Show, Enum, Bounded)
+
+data GlobalTool = ShimGen
+  deriving (Eq, GHC.Generic, Ord, Show, Enum, Bounded)
 
 
 -- | All necessary information of a tool version, including
 -- source download and per-architecture downloads.
 data VersionInfo = VersionInfo
-  { _viTags     :: [Tag]              -- ^ version specific tag
-  , _viSourceDL :: Maybe DownloadInfo -- ^ source tarball
-  , _viArch     :: ArchitectureSpec   -- ^ descend for binary downloads per arch
+  { _viTags        :: [Tag]              -- ^ version specific tag
+  , _viChangeLog   :: Maybe URI
+  , _viSourceDL    :: Maybe DownloadInfo -- ^ source tarball
+  , _viArch        :: ArchitectureSpec   -- ^ descend for binary downloads per arch
+  -- informative messages
+  , _viPostInstall :: Maybe Text
+  , _viPostRemove  :: Maybe Text
+  , _viPreCompile  :: Maybe Text
   }
-  deriving (Eq, Show)
+  deriving (Eq, GHC.Generic, Show)
 
 
 -- | A tag. These are currently attached to a version of a tool.
 data Tag = Latest
          | Recommended
-         deriving (Ord, Eq, Show)
+         | Prerelease
+         | Base PVP
+         | Old                -- ^ old version are hidden by default in TUI
+         | UnknownTag String  -- ^ used for upwardscompat
+         deriving (Ord, Eq, GHC.Generic, Show) -- FIXME: manual JSON instance
 
+tagToString :: Tag -> String
+tagToString Recommended        = "recommended"
+tagToString Latest             = "latest"
+tagToString Prerelease         = "prerelease"
+tagToString (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
+tagToString (UnknownTag t    ) = t
+tagToString Old                = ""
+
+instance Pretty Tag where
+  pPrint Recommended        = text "recommended"
+  pPrint Latest             = text "latest"
+  pPrint Prerelease         = text "prerelease"
+  pPrint (Base       pvp'') = text ("base-" ++ T.unpack (prettyPVP pvp''))
+  pPrint (UnknownTag t    ) = text t
+  pPrint Old                = mempty
 
 data Architecture = A_64
                   | A_32
+                  | A_PowerPC
+                  | A_PowerPC64
+                  | A_Sparc
+                  | A_Sparc64
+                  | A_ARM
+                  | A_ARM64
   deriving (Eq, GHC.Generic, Ord, Show)
 
+archToString :: Architecture -> String
+archToString A_64 = "x86_64"
+archToString A_32 = "i386"
+archToString A_PowerPC = "powerpc"
+archToString A_PowerPC64 = "powerpc64"
+archToString A_Sparc = "sparc"
+archToString A_Sparc64 = "sparc64"
+archToString A_ARM = "arm"
+archToString A_ARM64 = "aarch64"
+
+instance Pretty Architecture where
+  pPrint = text . archToString
 
 data Platform = Linux LinuxDistro
               -- ^ must exit
               | Darwin
               -- ^ must exit
               | FreeBSD
+              | Windows
+              -- ^ must exit
   deriving (Eq, GHC.Generic, Ord, Show)
 
+platformToString :: Platform -> String
+platformToString (Linux distro) = "linux-" ++ distroToString distro
+platformToString Darwin = "darwin"
+platformToString FreeBSD = "freebsd"
+platformToString Windows = "windows"
+
+instance Pretty Platform where
+  pPrint = text . platformToString
+
 data LinuxDistro = Debian
                  | Ubuntu
                  | Mint
@@ -111,15 +206,31 @@ data LinuxDistro = Debian
                  -- ^ must exit
   deriving (Eq, GHC.Generic, Ord, Show)
 
+distroToString :: LinuxDistro -> String
+distroToString Debian = "debian"
+distroToString Ubuntu = "ubuntu"
+distroToString Mint= "mint"
+distroToString Fedora = "fedora"
+distroToString CentOS = "centos"
+distroToString RedHat = "redhat"
+distroToString Alpine = "alpine"
+distroToString AmazonLinux = "amazon"
+distroToString Gentoo = "gentoo"
+distroToString Exherbo = "exherbo"
+distroToString UnknownLinux = "unknown"
+
+instance Pretty LinuxDistro where
+  pPrint = text . distroToString
+
 
 -- | An encapsulation of a download. This can be used
 -- to download, extract and install a tool.
 data DownloadInfo = DownloadInfo
   { _dlUri    :: URI
-  , _dlSubdir :: Maybe (Path Rel)
+  , _dlSubdir :: Maybe TarDir
   , _dlHash   :: Text
   }
-  deriving (Eq, Show)
+  deriving (Eq, Ord, GHC.Generic, Show)
 
 
 
@@ -129,25 +240,121 @@ data DownloadInfo = DownloadInfo
     --------------
 
 
+-- | How to descend into a tar archive.
+data TarDir = RealDir FilePath
+            | RegexDir String     -- ^ will be compiled to regex, the first match will "win"
+            deriving (Eq, Ord, GHC.Generic, Show)
+
+instance Pretty TarDir where
+  pPrint (RealDir path) = text path
+  pPrint (RegexDir regex) = text regex
+
+
 -- | Where to fetch GHCupDownloads from.
 data URLSource = GHCupURL
                | OwnSource URI
                | OwnSpec GHCupInfo
-               deriving Show
+               | AddSource (Either GHCupInfo URI) -- ^ merge with GHCupURL
+               deriving (GHC.Generic, Show)
 
 
+data UserSettings = UserSettings
+  { uCache       :: Maybe Bool
+  , uNoVerify    :: Maybe Bool
+  , uVerbose     :: Maybe Bool
+  , uKeepDirs    :: Maybe KeepDirs
+  , uDownloader  :: Maybe Downloader
+  , uKeyBindings :: Maybe UserKeyBindings
+  , uUrlSource   :: Maybe URLSource
+  }
+  deriving (Show, GHC.Generic)
+
+defaultUserSettings :: UserSettings
+defaultUserSettings = UserSettings Nothing Nothing Nothing Nothing Nothing Nothing Nothing
+
+data UserKeyBindings = UserKeyBindings
+  { kUp        :: Maybe Key
+  , kDown      :: Maybe Key
+  , kQuit      :: Maybe Key
+  , kInstall   :: Maybe Key
+  , kUninstall :: Maybe Key
+  , kSet       :: Maybe Key
+  , kChangelog :: Maybe Key
+  , kShowAll   :: Maybe Key
+  , kShowAllTools :: Maybe Key
+  }
+  deriving (Show, GHC.Generic)
+
+data KeyBindings = KeyBindings
+  { bUp        :: Key
+  , bDown      :: Key
+  , bQuit      :: Key
+  , bInstall   :: Key
+  , bUninstall :: Key
+  , bSet       :: Key
+  , bChangelog :: Key
+  , bShowAllVersions :: Key
+  , bShowAllTools :: Key
+  }
+  deriving (Show, GHC.Generic)
+
+defaultKeyBindings :: KeyBindings
+defaultKeyBindings = KeyBindings
+  { bUp = KUp
+  , bDown = KDown
+  , bQuit = KChar 'q'
+  , bInstall = KChar 'i'
+  , bUninstall = KChar 'u'
+  , bSet = KChar 's'
+  , bChangelog = KChar 'c'
+  , bShowAllVersions = KChar 'a'
+  , bShowAllTools = KChar 't'
+  }
+
+data AppState = AppState
+  { settings :: Settings
+  , dirs :: Dirs
+  , keyBindings :: KeyBindings
+  , ghcupInfo :: GHCupInfo
+  , pfreq :: PlatformRequest
+  } deriving (Show)
+
 data Settings = Settings
-  { cache    :: Bool
-  , noVerify :: Bool
+  { cache      :: Bool
+  , noVerify   :: Bool
+  , keepDirs   :: KeepDirs
+  , downloader :: Downloader
+  , verbose    :: Bool
+  , urlSource  :: URLSource
+  }
+  deriving (Show, GHC.Generic)
+
+data Dirs = Dirs
+  { baseDir  :: FilePath
+  , binDir   :: FilePath
+  , cacheDir :: FilePath
+  , logsDir  :: FilePath
+  , confDir  :: FilePath
   }
   deriving Show
 
+data KeepDirs = Always
+              | Errors
+              | Never
+  deriving (Eq, Show, Ord)
+
+data Downloader = Curl
+                | Wget
+#if defined(INTERNAL_DOWNLOADER)
+                | Internal
+#endif
+  deriving (Eq, Show, Ord)
 
 data DebugInfo = DebugInfo
-  { diBaseDir  :: Path Abs
-  , diBinDir   :: Path Abs
-  , diGHCDir   :: Path Abs
-  , diCacheDir :: Path Abs
+  { diBaseDir  :: FilePath
+  , diBinDir   :: FilePath
+  , diGHCDir   :: FilePath
+  , diCacheDir :: FilePath
   , diArch     :: Architecture
   , diPlatform :: PlatformResult
   }
@@ -166,9 +373,90 @@ data PlatformResult = PlatformResult
   }
   deriving (Eq, Show)
 
+platResToString :: PlatformResult -> String
+platResToString PlatformResult { _platform = plat, _distroVersion = Just v' }
+  = show plat <> ", " <> T.unpack (prettyV v')
+platResToString PlatformResult { _platform = plat, _distroVersion = Nothing }
+  = show plat
+
+instance Pretty PlatformResult where
+  pPrint = text . platResToString
+
 data PlatformRequest = PlatformRequest
   { _rArch     :: Architecture
   , _rPlatform :: Platform
   , _rVersion  :: Maybe Versioning
   }
   deriving (Eq, Show)
+
+pfReqToString :: PlatformRequest -> String
+pfReqToString (PlatformRequest arch plat ver) =
+  archToString arch ++ "-" ++ platformToString plat ++ pver
+ where
+  pver = case ver of
+           Just v' -> "-" ++ T.unpack (prettyV v')
+           Nothing -> ""
+
+instance Pretty PlatformRequest where
+  pPrint = text . pfReqToString
+
+-- | A GHC identified by the target platform triple
+-- and the version.
+data GHCTargetVersion = GHCTargetVersion
+  { _tvTarget  :: Maybe Text
+  , _tvVersion :: Version
+  }
+  deriving (Ord, Eq, Show)
+
+data GitBranch = GitBranch
+  { ref  :: String
+  , repo :: Maybe String
+  }
+  deriving (Ord, Eq, Show)
+
+mkTVer :: Version -> GHCTargetVersion
+mkTVer = GHCTargetVersion Nothing
+
+tVerToText :: GHCTargetVersion -> Text
+tVerToText (GHCTargetVersion (Just t) v') = t <> "-" <> prettyVer v'
+tVerToText (GHCTargetVersion Nothing  v') = prettyVer v'
+
+-- | Assembles a path of the form: <target-triple>-<version>
+instance Pretty GHCTargetVersion where
+  pPrint = text . T.unpack . tVerToText
+
+
+-- | A comparator and a version.
+data VersionCmp = VR_gt Versioning
+                | VR_gteq Versioning
+                | VR_lt Versioning
+                | VR_lteq Versioning
+                | VR_eq Versioning
+  deriving (Eq, GHC.Generic, Ord, Show)
+
+
+-- | A version range. Supports && and ||, but not  arbitrary
+-- combinations. This is a little simplified.
+data VersionRange = SimpleRange (NonEmpty VersionCmp) -- And
+                  | OrRange (NonEmpty VersionCmp) VersionRange
+  deriving (Eq, GHC.Generic, Ord, Show)
+
+
+instance Pretty Versioning where
+  pPrint = text . T.unpack . prettyV
+
+instance Pretty Version where
+  pPrint = text . T.unpack . prettyVer
+
+
+instance (Monad m, Alternative m) => Alternative (LoggingT m) where
+    empty   = Trans.lift empty
+    {-# INLINE empty #-}
+    m <|> n = LoggingT $ \ r -> runLoggingT m r <|> runLoggingT n r
+    {-# INLINE (<|>) #-}
+
+
+instance MonadLogger m => MonadLogger (Excepts e m) where
+  monadLoggerLog a b c d = Trans.lift $ monadLoggerLog a b c d
+
+

lib/GHCup/Types/JSON.hs

@@ -10,41 +10,72 @@
 {-# LANGUAGE TemplateHaskell       #-}
 {-# LANGUAGE TypeFamilies          #-}
 
+{-|
+Module      : GHCup.Types.JSON
+Description : GHCup JSON types/instances
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+-}
 module GHCup.Types.JSON where
 
 import           GHCup.Types
+import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
 
+import           Control.Applicative            ( (<|>) )
 import           Data.Aeson
 import           Data.Aeson.TH
 import           Data.Aeson.Types
+import           Data.List.NonEmpty             ( NonEmpty(..) )
 import           Data.Text.Encoding            as E
 import           Data.Versions
-import           Data.Word8
-import           HPath
+import           Data.Void
 import           URI.ByteString
+import           Text.Casing
 
-import qualified Data.ByteString               as BS
+import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T
+import qualified Text.Megaparsec               as MP
+import qualified Text.Megaparsec.Char          as MPC
 
 
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } { fieldLabelModifier = removeLensFieldLabel } ''Architecture
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''LinuxDistro
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Mess
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Platform
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''SemVer
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VSep
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VUnit
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VersionInfo
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tag
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''DownloadInfo
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GHCupInfo
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Requirements
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''MChunk
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Platform
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Mess
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''SemVer
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GlobalTool
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''KeepDirs
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Downloader
 
+instance ToJSON Tag where
+  toJSON Latest             = String "Latest"
+  toJSON Recommended        = String "Recommended"
+  toJSON Prerelease         = String "Prerelease"
+  toJSON Old                = String "old"
+  toJSON (Base       pvp'') = String ("base-" <> prettyPVP pvp'')
+  toJSON (UnknownTag x    ) = String (T.pack x)
+
+instance FromJSON Tag where
+  parseJSON = withText "Tag" $ \t -> case T.unpack t of
+    "Latest"                             -> pure Latest
+    "Recommended"                        -> pure Recommended
+    "Prerelease"                         -> pure Prerelease
+    "old"                                -> pure Old
+    ('b' : 'a' : 's' : 'e' : '-' : ver') -> case pvp (T.pack ver') of
+      Right x -> pure $ Base x
+      Left  e -> fail . show $ e
+    x -> pure (UnknownTag x)
 
 instance ToJSON URI where
-  toJSON = toJSON . decodeUtf8 . serializeURIRef'
+  toJSON = toJSON . decUTF8Safe . serializeURIRef'
 
 instance FromJSON URI where
   parseJSON = withText "URL" $ \t ->
@@ -75,10 +106,10 @@ instance ToJSONKey (Maybe Versioning) where
 
 instance FromJSONKey (Maybe Versioning) where
   fromJSONKey = FromJSONKeyTextParser $ \t ->
-    if t == T.pack "unknown_versioning" then pure Nothing else pure $ just t
+    if t == T.pack "unknown_versioning" then pure Nothing else just t
    where
     just t = case versioning t of
-      Right x -> pure x
+      Right x -> pure $ Just x
       Left  e -> fail $ "Failure in (Maybe Versioning) (FromJSONKey)" <> show e
 
 instance ToJSONKey Platform where
@@ -86,11 +117,13 @@ instance ToJSONKey Platform where
     Darwin  -> T.pack "Darwin"
     FreeBSD -> T.pack "FreeBSD"
     Linux d -> T.pack ("Linux_" <> show d)
+    Windows -> T.pack "Windows"
 
 instance FromJSONKey Platform where
   fromJSONKey = FromJSONKeyTextParser $ \t -> if
     | T.pack "Darwin" == t -> pure Darwin
     | T.pack "FreeBSD" == t -> pure FreeBSD
+    | T.pack "Windows" == t -> pure Windows
     | T.pack "Linux_" `T.isPrefixOf` t -> case
         T.stripPrefix (T.pack "Linux_") t
       of
@@ -106,7 +139,7 @@ instance FromJSONKey Platform where
                   $  "Unexpected failure in decoding LinuxDistro: "
                   <> show dstr
         Nothing -> fail "Unexpected failure in Platform stripPrefix"
-    | otherwise -> fail $ "Failure in Platform (FromJSONKey)"
+    | otherwise -> fail "Failure in Platform (FromJSONKey)"
 
 instance ToJSONKey Architecture where
   toJSONKey = genericToJSONKey defaultJSONKeyOptions
@@ -121,10 +154,10 @@ instance ToJSONKey (Maybe Version) where
 
 instance FromJSONKey (Maybe Version) where
   fromJSONKey = FromJSONKeyTextParser $ \t ->
-    if t == T.pack "unknown_version" then pure Nothing else pure $ just t
+    if t == T.pack "unknown_version" then pure Nothing else just t
    where
     just t = case version t of
-      Right x -> pure x
+      Right x -> pure $ Just x
       Left  e -> fail $ "Failure in (Maybe Version) (FromJSONKey)" <> show e
 
 instance ToJSON Version where
@@ -143,21 +176,143 @@ instance FromJSONKey Version where
     Right x -> pure x
     Left  e -> fail $ "Failure in Version (FromJSONKey)" <> show e
 
+instance ToJSON PVP where
+  toJSON = toJSON . prettyPVP
+
+instance FromJSON PVP where
+  parseJSON = withText "PVP" $ \t -> case pvp t of
+    Right x -> pure x
+    Left  e -> fail $ "Failure in PVP (FromJSON)" <> show e
+
 instance ToJSONKey Tool where
   toJSONKey = genericToJSONKey defaultJSONKeyOptions
 
 instance FromJSONKey Tool where
   fromJSONKey = genericFromJSONKey defaultJSONKeyOptions
 
-instance ToJSON (Path Rel) where
-  toJSON p = case and . fmap isAscii . BS.unpack $ fp of
-    True  -> toJSON . E.decodeUtf8 $ fp
-    False -> String "/not/a/valid/path"
-    where fp = toFilePath p
+instance ToJSONKey GlobalTool where
+  toJSONKey = genericToJSONKey defaultJSONKeyOptions
 
-instance FromJSON (Path Rel) where
-  parseJSON = withText "HPath Rel" $ \t -> do
-    let d = encodeUtf8 t
-    case parseRel d of
-      Right x -> pure x
-      Left  e -> fail $ "Failure in HPath Rel (FromJSON)" <> show e
+instance FromJSONKey GlobalTool where
+  fromJSONKey = genericFromJSONKey defaultJSONKeyOptions
+
+instance ToJSON TarDir where
+  toJSON (RealDir  p) = toJSON p
+  toJSON (RegexDir r) = object ["RegexDir" .= r]
+
+instance FromJSON TarDir where
+  parseJSON v = realDir v <|> regexDir v
+   where
+    realDir = withText "TarDir" $ \t -> do
+      fp <- parseJSON (String t)
+      pure (RealDir fp)
+    regexDir = withObject "TarDir" $ \o -> do
+      r <- o .: "RegexDir"
+      pure $ RegexDir r
+
+
+instance ToJSON VersionCmp where
+  toJSON = String . versionCmpToText
+
+instance FromJSON VersionCmp where
+  parseJSON = withText "VersionCmp" $ \t -> do
+    case MP.parse versionCmpP "" t of
+      Right r -> pure r
+      Left  e -> fail (MP.errorBundlePretty e)
+
+versionCmpToText :: VersionCmp -> T.Text
+versionCmpToText (VR_gt   ver') = "> " <> prettyV ver'
+versionCmpToText (VR_gteq ver') = ">= " <> prettyV ver'
+versionCmpToText (VR_lt   ver') = "< " <> prettyV ver'
+versionCmpToText (VR_lteq ver') = "<= " <> prettyV ver'
+versionCmpToText (VR_eq   ver') = "== " <> prettyV ver'
+
+versionCmpP :: MP.Parsec Void T.Text VersionCmp
+versionCmpP =
+  fmap VR_gt (MP.try $ MPC.space *> MP.chunk ">" *> MPC.space *> versioningEnd)
+    <|> fmap
+          VR_gteq
+          (MP.try $ MPC.space *> MP.chunk ">=" *> MPC.space *> versioningEnd)
+    <|> fmap
+          VR_lt
+          (MP.try $ MPC.space *> MP.chunk "<" *> MPC.space *> versioningEnd)
+    <|> fmap
+          VR_lteq
+          (MP.try $ MPC.space *> MP.chunk "<=" *> MPC.space *> versioningEnd)
+    <|> fmap
+          VR_eq
+          (MP.try $ MPC.space *> MP.chunk "==" *> MPC.space *> versioningEnd)
+    <|> fmap
+          VR_eq
+          (MP.try $ MPC.space *> versioningEnd)
+
+instance ToJSON VersionRange where
+  toJSON = String . verRangeToText
+
+verRangeToText :: VersionRange -> T.Text
+verRangeToText  (SimpleRange cmps) =
+  let inner = foldr1 (\x y -> x <> " && " <> y)
+                     (versionCmpToText <$> NE.toList cmps)
+  in  "( " <> inner <> " )"
+verRangeToText (OrRange cmps range) =
+  let left  = verRangeToText (SimpleRange cmps)
+      right = verRangeToText range
+  in  left <> " || " <> right
+
+instance FromJSON VersionRange where
+  parseJSON = withText "VersionRange" $ \t -> do
+    case MP.parse versionRangeP "" t of
+      Right r -> pure r
+      Left  e -> fail (MP.errorBundlePretty e)
+
+versionRangeP :: MP.Parsec Void T.Text VersionRange
+versionRangeP = go <* MP.eof
+ where
+  go =
+    MP.try orParse
+      <|> MP.try (fmap SimpleRange andParse)
+      <|> fmap (SimpleRange . pure) versionCmpP
+
+  orParse :: MP.Parsec Void T.Text VersionRange
+  orParse =
+    (\a o -> OrRange a o)
+      <$> (MP.try andParse <|> fmap pure versionCmpP)
+      <*> (MPC.space *> MP.chunk "||" *> MPC.space *> go)
+
+  andParse :: MP.Parsec Void T.Text (NonEmpty VersionCmp)
+  andParse =
+    fmap (\h t -> h :| t)
+         (MPC.space *> MP.chunk "(" *> MPC.space *> versionCmpP)
+      <*> MP.try (MP.many (MPC.space *> MP.chunk "&&" *> MPC.space *> versionCmpP))
+      <*  MPC.space
+      <*  MP.chunk ")"
+      <*  MPC.space
+
+versioningEnd :: MP.Parsec Void T.Text Versioning
+versioningEnd =
+  MP.try (verP (MP.chunk " " <|> MP.chunk ")" <|> MP.chunk "&&") <* MPC.space)
+    <|> versioning'
+
+instance ToJSONKey (Maybe VersionRange) where
+  toJSONKey = toJSONKeyText $ \case
+    Just x -> verRangeToText x
+    Nothing -> "unknown_versioning"
+
+instance FromJSONKey (Maybe VersionRange)  where
+  fromJSONKey = FromJSONKeyTextParser $ \t ->
+    if t == T.pack "unknown_versioning" then pure Nothing else just t
+   where
+    just t = case MP.parse versionRangeP "" t of
+      Right x -> pure $ Just x
+      Left  e -> fail $ "Failure in (Maybe VersionRange) (FromJSONKey)" <> MP.errorBundlePretty e
+
+
+
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Requirements
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''DownloadInfo
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''VersionInfo
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GHCupInfo
+deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''URLSource
+deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''Key
+deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "k-") . T.pack . kebab $ str' } ''UserKeyBindings
+deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "u-") . T.pack . kebab $ str' } ''UserSettings

lib/GHCup/Types/Optics.hs

@@ -1,5 +1,14 @@
 {-# LANGUAGE TemplateHaskell #-}
 
+{-|
+Module      : GHCup.Types.Optics
+Description : GHCup optics
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+-}
 module GHCup.Types.Optics where
 
 import           GHCup.Types
@@ -19,6 +28,8 @@ makeLenses ''DownloadInfo
 makeLenses ''Tag
 makeLenses ''VersionInfo
 
+makeLenses ''GHCTargetVersion
+
 makeLenses ''GHCupInfo
 
 uriSchemeL' :: Lens' (URIRef Absolute) Scheme

lib/GHCup/Utils.hs-boot

@@ -0,0 +1,4 @@
+module GHCup.Utils where
+
+getLinkTarget :: FilePath -> IO FilePath
+pathIsLink :: FilePath -> IO Bool

lib/GHCup/Utils/Bash.hs

@@ -1,69 +0,0 @@
-module GHCup.Utils.Bash
-  ( findAssignment
-  , equalsAssignmentWith
-  , getRValue
-  , getAssignmentValueFor
-  )
-where
-
-import           Control.Monad
-import           Data.ByteString.UTF8           ( toString )
-import           Data.List
-import           Data.Maybe
-import           HPath
-import           HPath.IO
-import           Language.Bash.Parse
-import           Language.Bash.Syntax
-import           Language.Bash.Word
-import           Prelude                 hiding ( readFile )
-
-import qualified Data.ByteString.Lazy.UTF8     as UTF8
-
-
-extractAssignments :: List -> [Assign]
-extractAssignments (List stms) = join $ fmap getAssign $ getCommands stms
- where
-  getCommands :: [Statement] -> [Command]
-  getCommands = join . fmap commands . catMaybes . fmap findPipes
-   where
-    findPipes (Statement (Last p@(Pipeline{})) Sequential) = Just p
-    findPipes _ = Nothing
-
-  getAssign :: Command -> [Assign]
-  getAssign (Command (SimpleCommand ass _) _) = ass
-  getAssign _ = []
-
-
--- | Find an assignment matching the predicate in the given file.
-findAssignment :: Path b -> (Assign -> Bool) -> IO (Maybe Assign)
-findAssignment p predicate = do
-  fileContents <- readFile p
-  -- TODO: this should accept bytestring:
-  --       https://github.com/knrafto/language-bash/issues/37
-  case parse (toString . toFilePath $ p) (UTF8.toString fileContents) of
-    Left  e -> fail $ show e
-    Right l -> pure $ find predicate (extractAssignments $ l)
-
-
--- | Check that the assignment is of the form Foo= ignoring the
--- right hand-side.
-equalsAssignmentWith :: String -> Assign -> Bool
-equalsAssignmentWith n ass = case ass of
-  (Assign (Parameter name' Nothing) Equals _) -> n == name'
-  _ -> False
-
-
--- | This pretty-prints the right hand of an Equals assignment, removing
--- quotations. No evaluation is performed.
-getRValue :: Assign -> Maybe String
-getRValue ass = case ass of
-  (Assign (Parameter _ _) Equals (RValue w)) -> Just $ unquote w
-  _ -> Nothing
-
-
--- | Given a bash assignment such as Foo="Bar" in the given file,
--- will return "Bar" (without quotations).
-getAssignmentValueFor :: Path b -> String -> IO (Maybe String)
-getAssignmentValueFor p n = do
-  mass <- findAssignment p (equalsAssignmentWith n)
-  pure (mass >>= getRValue)

lib/GHCup/Utils/Dirs.hs

@@ -1,79 +1,275 @@
+{-# LANGUAGE CPP                   #-}
+{-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE ViewPatterns          #-}
+{-# LANGUAGE TemplateHaskell       #-}
 
-module GHCup.Utils.Dirs where
+{-|
+Module      : GHCup.Utils.Dirs
+Description : Definition of GHCup directories
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+-}
+module GHCup.Utils.Dirs
+  ( getDirs
+  , ghcupBaseDir
+  , ghcupConfigFile
+  , ghcupCacheDir
+  , ghcupGHCBaseDir
+  , ghcupGHCDir
+  , mkGhcupTmpDir
+  , parseGHCupGHCDir
+  , relativeSymlink
+  , withGHCupTmpDir
+  )
+where
 
 
+import           GHCup.Errors
+import           GHCup.Types
 import           GHCup.Types.JSON               ( )
+import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
 
-import           Control.Applicative
 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
+import           Control.Monad.Trans.Resource hiding (throwM)
+import           Data.Bifunctor
 import           Data.Maybe
-import           Data.Versions
-import           HPath
-import           HPath.IO
+import           Data.String.Interpolate
+import           GHC.IO.Exception               ( IOErrorType(NoSuchThing) )
+import           Haskus.Utils.Variant.Excepts
+#if !defined(IS_WINDOWS)
 import           Optics
-import           Prelude                 hiding ( abs
-                                                , readFile
-                                                , writeFile
-                                                )
-import           System.Posix.Env.ByteString    ( getEnv
-                                                , getEnvDefault
-                                                )
-import           System.Posix.Temp.ByteString   ( mkdtemp )
+import           System.Directory                                                
+#endif
+import           System.DiskSpace                                                
+#if !defined(IS_WINDOWS)
+import           System.Environment
+#endif
+import           System.FilePath
+import           System.IO.Temp
 
-import qualified Data.ByteString.UTF8          as UTF8
-import qualified System.Posix.FilePath         as FP
-import qualified System.Posix.User             as PU
+import qualified Data.ByteString               as BS
+import qualified Data.Text                     as T
+import qualified Data.Yaml                     as Y
+import qualified Text.Megaparsec               as MP
+import Control.Concurrent (threadDelay)
 
 
 
+    ------------------------------
+    --[ GHCup base directories ]--
+    ------------------------------
+
+
+-- | ~/.ghcup by default
+--
+-- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
+-- then uses 'XDG_DATA_HOME/ghcup' as per xdg spec.
+ghcupBaseDir :: IO FilePath
+ghcupBaseDir = do
+#if defined(IS_WINDOWS)
+  pure ("C:\\" </> "ghcup")
+#else
+  xdg <- useXDG
+  if xdg
+    then do
+      bdir <- lookupEnv "XDG_DATA_HOME" >>= \case
+        Just r  -> pure r
+        Nothing -> do
+          home <- liftIO getHomeDirectory
+          pure (home </> ".local" </> "share")
+      pure (bdir </> "ghcup")
+    else do
+      bdir <- lookupEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
+        Just r  -> pure r
+        Nothing -> liftIO getHomeDirectory
+      pure (bdir </> ".ghcup")
+#endif
+
+
+-- | ~/.ghcup by default
+--
+-- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
+-- then uses 'XDG_CONFIG_HOME/ghcup' as per xdg spec.
+ghcupConfigDir :: IO FilePath
+ghcupConfigDir = do
+#if defined(IS_WINDOWS)
+  pure ("C:\\" </> "ghcup")
+#else
+  xdg <- useXDG
+  if xdg
+    then do
+      bdir <- lookupEnv "XDG_CONFIG_HOME" >>= \case
+        Just r  -> pure r
+        Nothing -> do
+          home <- liftIO getHomeDirectory
+          pure (home </> ".config")
+      pure (bdir </> "ghcup")
+    else do
+      bdir <- lookupEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
+        Just r  -> pure r
+        Nothing -> liftIO getHomeDirectory
+      pure (bdir </> ".ghcup")
+#endif
+
+
+-- | If 'GHCUP_USE_XDG_DIRS' is set (to anything),
+-- then uses 'XDG_BIN_HOME' env var or defaults to '~/.local/bin'
+-- (which, sadly is not strictly xdg spec).
+ghcupBinDir :: IO FilePath
+ghcupBinDir = do
+#if defined(IS_WINDOWS)
+  pure ("C:\\" </> "ghcup" </> "bin")
+#else
+  xdg <- useXDG
+  if xdg
+    then do
+      lookupEnv "XDG_BIN_HOME" >>= \case
+        Just r  -> pure r
+        Nothing -> do
+          home <- liftIO getHomeDirectory
+          pure (home </> ".local" </> "bin")
+    else ghcupBaseDir <&> (</> "bin")
+#endif
+
+
+-- | Defaults to '~/.ghcup/cache'.
+--
+-- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
+-- then uses 'XDG_CACHE_HOME/ghcup' as per xdg spec.
+ghcupCacheDir :: IO FilePath
+ghcupCacheDir = do
+#if defined(IS_WINDOWS)
+  pure ("C:\\" </> "ghcup" </> "cache")
+#else
+  xdg <- useXDG
+  if xdg
+    then do
+      bdir <- lookupEnv "XDG_CACHE_HOME" >>= \case
+        Just r  -> pure r
+        Nothing -> do
+          home <- liftIO getHomeDirectory
+          pure (home </> ".cache")
+      pure (bdir </> "ghcup")
+    else ghcupBaseDir <&> (</> "cache")
+#endif
+
+
+-- | Defaults to '~/.ghcup/logs'.
+--
+-- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
+-- then uses 'XDG_CACHE_HOME/ghcup/logs' as per xdg spec.
+ghcupLogsDir :: IO FilePath
+ghcupLogsDir = do
+#if defined(IS_WINDOWS)
+  pure ("C:\\" </> "ghcup" </> "logs")
+#else
+  xdg <- useXDG
+  if xdg
+    then do
+      bdir <- lookupEnv "XDG_CACHE_HOME" >>= \case
+        Just r  -> pure r
+        Nothing -> do
+          home <- liftIO getHomeDirectory
+          pure (home </> ".cache")
+      pure (bdir </> "ghcup" </> "logs")
+    else ghcupBaseDir <&> (</> "logs")
+#endif
+
+
+getDirs :: IO Dirs
+getDirs = do
+  baseDir  <- ghcupBaseDir
+  binDir   <- ghcupBinDir
+  cacheDir <- ghcupCacheDir
+  logsDir  <- ghcupLogsDir
+  confDir  <- ghcupConfigDir
+  pure Dirs { .. }
+
+
+
+    -------------------
+    --[ GHCup files ]--
+    -------------------
+
+
+ghcupConfigFile :: (MonadIO m)
+                => Excepts '[JSONError] m UserSettings
+ghcupConfigFile = do
+  confDir <- liftIO ghcupConfigDir
+  let file = confDir </> "config.yaml"
+  contents <- liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ Just <$> BS.readFile file
+  case contents of
+      Nothing -> pure defaultUserSettings
+      Just contents' -> lE' JSONDecodeError . first show . Y.decodeEither' $ contents'
+
+
     -------------------------
     --[ GHCup directories ]--
     -------------------------
 
 
-ghcupBaseDir :: IO (Path Abs)
-ghcupBaseDir = do
-  getEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
-    Just r  -> parseAbs r
-    Nothing -> do
-      home <- liftIO getHomeDirectory
-      pure (home </> [rel|.ghcup|])
+-- | ~/.ghcup/ghc by default.
+ghcupGHCBaseDir :: (MonadReader AppState m) => m FilePath
+ghcupGHCBaseDir = do
+  AppState { dirs = Dirs {..} } <- ask
+  pure (baseDir </> "ghc")
 
-ghcupGHCBaseDir :: IO (Path Abs)
-ghcupGHCBaseDir = ghcupBaseDir <&> (</> [rel|ghc|])
 
-ghcupGHCDir :: Version -> IO (Path Abs)
+-- | Gets '~/.ghcup/ghc/<ghcupGHCDir>'.
+-- The dir may be of the form
+--   * armv7-unknown-linux-gnueabihf-8.8.3
+--   * 8.8.4
+ghcupGHCDir :: (MonadReader AppState m, MonadThrow m)
+            => GHCTargetVersion
+            -> m FilePath
 ghcupGHCDir ver = do
   ghcbasedir <- ghcupGHCBaseDir
-  verdir     <- parseRel (verToBS ver)
+  let verdir = T.unpack $ tVerToText ver
   pure (ghcbasedir </> verdir)
 
 
-ghcupBinDir :: IO (Path Abs)
-ghcupBinDir = ghcupBaseDir <&> (</> [rel|bin|])
-
-ghcupCacheDir :: IO (Path Abs)
-ghcupCacheDir = ghcupBaseDir <&> (</> [rel|cache|])
-
-ghcupLogsDir :: IO (Path Abs)
-ghcupLogsDir = ghcupBaseDir <&> (</> [rel|logs|])
+-- | See 'ghcupToolParser'.
+parseGHCupGHCDir :: MonadThrow m => FilePath -> m GHCTargetVersion
+parseGHCupGHCDir (T.pack -> fp) =
+  throwEither $ MP.parse ghcTargetVerP "" fp
 
 
-mkGhcupTmpDir :: (MonadThrow m, MonadIO m) => m (Path Abs)
+mkGhcupTmpDir :: (MonadUnliftIO m, MonadLogger m, MonadCatch m, MonadThrow m, MonadIO m) => m FilePath
 mkGhcupTmpDir = do
-  tmpdir <- liftIO $ getEnvDefault "TMPDIR" "/tmp"
-  tmp    <- liftIO $ mkdtemp $ (tmpdir FP.</> "ghcup-")
-  parseAbs tmp
+  tmpdir <- liftIO getCanonicalTemporaryDirectory
+
+  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)
+      "...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)
+  truncate' :: Double -> Int -> Double
+  truncate' x n = fromIntegral (floor (x * t) :: Integer) / t
+      where t = 10^n
+
+
+withGHCupTmpDir :: (MonadUnliftIO m, MonadLogger m, MonadCatch m, MonadResource m, MonadThrow m, MonadIO m) => m FilePath
+withGHCupTmpDir = snd <$> withRunInIO (\run -> run $ allocate (run mkGhcupTmpDir) rmPath)
 
 
-withGHCupTmpDir :: (MonadResource m, MonadThrow m, MonadIO m) => m (Path Abs)
-withGHCupTmpDir = snd <$> allocate mkGhcupTmpDir deleteDirRecursive
 
 
     --------------
@@ -81,11 +277,21 @@ withGHCupTmpDir = snd <$> allocate mkGhcupTmpDir deleteDirRecursive
     --------------
 
 
-getHomeDirectory :: IO (Path Abs)
-getHomeDirectory = do
-  e <- getEnv "HOME"
-  case e of
-    Just fp -> parseAbs fp
-    Nothing -> do
-      h <- PU.homeDirectory <$> (PU.getEffectiveUserID >>= PU.getUserEntryForID)
-      parseAbs $ UTF8.fromString h -- this is a guess
+#if !defined(IS_WINDOWS)
+useXDG :: IO Bool
+useXDG = isJust <$> lookupEnv "GHCUP_USE_XDG_DIRS"
+#endif
+
+
+relativeSymlink :: FilePath  -- ^ the path in which to create the symlink
+                -> FilePath  -- ^ the symlink destination
+                -> FilePath
+relativeSymlink p1 p2 =
+  let d1      = splitDirectories p1
+      d2      = splitDirectories p2
+      common  = takeWhile (\(x, y) -> x == y) $ zip d1 d2
+      cPrefix = drop (length common) d1
+  in  joinPath (replicate (length cPrefix) "..")
+        <> joinPath ([pathSeparator] : drop (length common) d2)
+
+

lib/GHCup/Utils/File.hs

@@ -1,385 +1,17 @@
-{-# LANGUAGE QuasiQuotes       #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE CPP #-}
 
-module GHCup.Utils.File where
+module GHCup.Utils.File (
+  module GHCup.Utils.File.Common,
+#if IS_WINDOWS
+  module GHCup.Utils.File.Windows
+#else
+  module GHCup.Utils.File.Posix
+#endif
+) where
 
-import           GHCup.Utils.Dirs
-import           GHCup.Utils.Prelude
-
-import           Control.Concurrent
-import           Control.Exception              ( evaluate )
-import           Control.Exception.Safe
-import           Control.Monad
-import           Data.ByteString                ( ByteString )
-import           Data.ByteString.Unsafe         ( unsafeUseAsCStringLen )
-import           Data.Char
-import           Data.Foldable
-import           Data.Functor
-import           Data.IORef
-import           Data.Maybe
-import           GHC.Foreign                    ( peekCStringLen )
-import           GHC.IO.Encoding                ( getLocaleEncoding )
-import           GHC.IO.Exception
-import           HPath
-import           HPath.IO
-import           Optics
-import           Streamly
-import           Streamly.External.ByteString
-import           Streamly.External.ByteString.Lazy
-import           System.Console.Pretty
-import           System.Console.Regions
-import           System.IO
-import           System.IO.Error
-import           System.Posix.Directory.ByteString
-import           System.Posix.FD               as FD
-import           System.Posix.FilePath   hiding ( (</>) )
-import           System.Posix.Foreign           ( oExcl )
-import "unix"    System.Posix.IO.ByteString
-                                         hiding ( openFd )
-import           System.Posix.Process           ( ProcessStatus(..) )
-import           System.Posix.Types
-
-
-import qualified Control.Exception             as EX
-import qualified Data.Text                     as T
-import qualified Data.Text.Encoding            as E
-import qualified Data.Text.Encoding.Error      as E
-import qualified System.Posix.Process.ByteString
-                                               as SPPB
-import           Streamly.External.Posix.DirStream
-import qualified Streamly.Internal.Memory.ArrayStream
-                                               as AS
-import qualified Streamly.FileSystem.Handle    as FH
-import qualified Streamly.Internal.Data.Unfold as SU
-import qualified Streamly.Prelude              as S
-import qualified Data.ByteString               as BS
-import qualified Data.ByteString.Lazy          as L
-import qualified "unix-bytestring" System.Posix.IO.ByteString
-                                               as SPIB
-
-
--- | Bool signals whether the regions should be cleaned.
-data StopThread = StopThread Bool
-  deriving Show
-
-instance Exception StopThread
-
-
-data ProcessError = NonZeroExit Int ByteString [ByteString]
-                  | PTerminated ByteString [ByteString]
-                  | PStopped ByteString [ByteString]
-                  | NoSuchPid ByteString [ByteString]
-                  deriving Show
-
-
-data CapturedProcess = CapturedProcess
-  { _exitCode :: ExitCode
-  , _stdOut   :: ByteString
-  , _stdErr   :: ByteString
-  }
-  deriving (Eq, Show)
-
-makeLenses ''CapturedProcess
-
-
-readFd :: Fd -> IO L.ByteString
-readFd fd = do
-  handle' <- fdToHandle fd
-  fromChunksIO $ (S.unfold (SU.finallyIO hClose FH.readChunks) handle')
-
-
--- | Read the lines of a file into a stream. The stream holds
--- a file handle as a resource and will close it once the stream
--- terminates (either through exception or because it's drained).
-readFileLines :: Path b -> IO (SerialT IO ByteString)
-readFileLines p = do
-  stream <- readFileStream p
-  pure
-    . (fmap fromArray)
-    . AS.splitOn (fromIntegral $ ord '\n')
-    . (fmap toArray)
-    $ stream
-
-
--- | Find the given executable by searching all *absolute* PATH components.
--- Relative paths in PATH are ignored.
---
--- This shouldn't throw IO exceptions, unless getting the environment variable
--- PATH does.
-findExecutable :: Path Rel -> IO (Maybe (Path Abs))
-findExecutable ex = do
-  sPaths <- fmap catMaybes . (fmap . fmap) parseAbs $ getSearchPath
-  -- We don't want exceptions to mess up our result. If we can't
-  -- figure out if a file exists, then treat it as a negative result.
-  asum $ fmap (handleIO (\_ -> pure Nothing)) $ fmap
-    -- asum for short-circuiting behavior
-    (\s' -> (isExecutable (s' </> ex) >>= guard) $> (Just (s' </> ex)))
-    sPaths
-
-
--- | Execute the given command and collect the stdout, stderr and the exit code.
--- The command is run in a subprocess.
-executeOut :: Path b            -- ^ command as filename, e.g. 'ls'
-           -> [ByteString]      -- ^ arguments to the command
-           -> Maybe (Path Abs)  -- ^ chdir to this path
-           -> IO CapturedProcess
-executeOut path args chdir = captureOutStreams $ do
-  maybe (pure ()) (changeWorkingDirectory . toFilePath) chdir
-  SPPB.executeFile (toFilePath path) True args Nothing
-
-
-execLogged :: ByteString       -- ^ thing to execute
-           -> Bool             -- ^ whether to search PATH for the thing
-           -> [ByteString]     -- ^ args for the thing
-           -> Path Rel         -- ^ log filename
-           -> Maybe (Path Abs) -- ^ optionally chdir into this
-           -> Maybe [(ByteString, ByteString)] -- ^ optional environment
-           -> IO (Either ProcessError ())
-execLogged exe spath args lfile chdir env = do
-  ldir    <- ghcupLogsDir
-  logfile <- (ldir </>) <$> parseRel (toFilePath lfile <> ".log")
-  bracket (createFile (toFilePath logfile) newFilePerms) closeFd action
- where
-  action fd = do
-    actionWithPipes $ \(stdoutRead, stdoutWrite) -> do
-      -- start the thread that logs to stdout in a region
-      done <- newEmptyMVar
-      tid  <-
-        forkIO
-        $ EX.handle (\(_ :: StopThread) -> pure ())
-        $ EX.handle (\(_ :: IOException) -> pure ())
-        $ flip finally (putMVar done ())
-        $ printToRegion fd stdoutRead 6
-
-      -- fork our subprocess
-      pid <- SPPB.forkProcess $ do
-        void $ dupTo stdoutWrite stdOutput
-        void $ dupTo stdoutWrite stdError
-        closeFd stdoutWrite
-        closeFd stdoutRead
-
-        -- execute the action
-        maybe (pure ()) (changeWorkingDirectory . toFilePath) chdir
-        SPPB.executeFile exe spath args env
-
-      closeFd stdoutWrite
-
-      -- wait for the subprocess to finish
-      e <- SPPB.getProcessStatus True True pid >>= \case
-        i@(Just (SPPB.Exited _)) -> pure $ toProcessError exe args i
-        i                        -> pure $ toProcessError exe args i
-
-      -- make sure the logging thread stops
-      case e of
-        Left  _ -> EX.throwTo tid (StopThread False)
-        Right _ -> EX.throwTo tid (StopThread True)
-      takeMVar done
-
-      closeFd stdoutRead
-      pure e
-
-  -- Reads fdIn and logs the output in a continous scrolling area
-  -- of 'size' terminal lines. Also writes to a log file.
-  printToRegion fileFd fdIn size = do
-    ref <- newIORef ([] :: [ByteString])
-    displayConsoleRegions $ do
-      rs <- sequence . replicate size . openConsoleRegion $ Linear
-      flip finally (readTilEOF (lineAction ref rs) fdIn) -- make sure the last few lines don't get cut off
-        $ handle
-            (\(StopThread b) -> do
-              when b (forM_ rs closeConsoleRegion)
-              EX.throw (StopThread b)
-            )
-        $ do
-            hideError eofErrorType $ readTilEOF (lineAction ref rs) fdIn
-            -- wait for explicit stop from the parent to signal what cleanup to run
-            forever (threadDelay 5000)
-
-   where
-    -- action to perform line by line
-    lineAction ref rs bs' = do
-      modifyIORef' ref (swapRegs bs')
-      regs <- readIORef ref
-      forM (zip regs rs) $ \(bs, r) -> do
-        setConsoleRegion r $ do
-          w <- consoleWidth
-          return
-            . T.pack
-            . color Blue
-            . T.unpack
-            . E.decodeUtf8With E.lenientDecode
-            . trim w
-            . (\b -> "[ " <> toFilePath lfile <> " ] " <> b)
-            $ bs
-        SPIB.fdWrite fileFd (bs <> "\n")
-
-
-    swapRegs bs regs | length regs < size = regs ++ [bs]
-                     | otherwise          = tail regs ++ [bs]
-
-    -- trim output line to terminal width
-    trim w bs | BS.length bs > w && w > 5 = BS.take (w - 4) bs <> "..."
-              | otherwise                 = bs
-
-    -- read an entire line from the file descriptor (removes the newline char)
-    readLine fd' = do
-      bs <- SPIB.fdRead fd' 1
-      if
-        | bs == "\n" -> pure ""
-        | bs == ""   -> pure ""
-        | otherwise  -> fmap (bs <>) $ readLine fd'
-
-    readTilEOF action' fd' = do
-      bs <- readLine fd'
-      void $ action' bs
-      readTilEOF action' fd'
-
-
--- | Capture the stdout and stderr of the given action, which
--- is run in a subprocess. Stdin is closed. You might want to
--- 'race' this to make sure it terminates.
-captureOutStreams :: IO a
-                     -- ^ the action to execute in a subprocess
-                  -> IO CapturedProcess
-captureOutStreams action = do
-  actionWithPipes $ \(parentStdoutRead, childStdoutWrite) ->
-    actionWithPipes $ \(parentStderrRead, childStderrWrite) -> do
-      pid <- SPPB.forkProcess $ do
-        -- dup stdout
-        void $ dupTo childStdoutWrite stdOutput
-        closeFd childStdoutWrite
-        closeFd parentStdoutRead
-
-        -- dup stderr
-        void $ dupTo childStderrWrite stdError
-        closeFd childStderrWrite
-        closeFd parentStderrRead
-
-        -- execute the action
-        a <- action
-        void $ evaluate a
-
-      -- close everything we don't need
-      closeFd childStdoutWrite
-      closeFd childStderrWrite
-
-      -- start thread that writes the output
-      refOut <- newIORef BS.empty
-      refErr <- newIORef BS.empty
-      done   <- newEmptyMVar
-      _      <-
-        forkIO
-        $ EX.handle (\(_ :: StopThread) -> pure ())
-        $ EX.handle (\(_ :: IOException) -> pure ())
-        $ flip finally (putMVar done ())
-        $ writeStds parentStdoutRead parentStderrRead refOut refErr
-
-      status <- SPPB.getProcessStatus True True pid
-      takeMVar done
-
-      case status of
-        -- readFd will take care of closing the fd
-        Just (SPPB.Exited es) -> do
-          stdout' <- readIORef refOut
-          stderr' <- readIORef refErr
-          pure $ CapturedProcess { _exitCode = es
-                                 , _stdOut   = stdout'
-                                 , _stdErr   = stderr'
-                                 }
-
-        _ -> throwIO $ userError $ ("No such PID " ++ show pid)
-
- where
-  writeStds pout perr rout rerr = do
-    doneOut <- newEmptyMVar
-    void
-      $ forkIO
-      $ hideError eofErrorType
-      $ flip finally (putMVar doneOut ())
-      $ readTilEOF (\x -> modifyIORef' rout (<> x)) pout
-    doneErr <- newEmptyMVar
-    void
-      $ forkIO
-      $ hideError eofErrorType
-      $ flip finally (putMVar doneErr ())
-      $ readTilEOF (\x -> modifyIORef' rerr (<> x)) perr
-    takeMVar doneOut
-    takeMVar doneErr
-
-  readTilEOF ~action' fd' = do
-    bs <- SPIB.fdRead fd' 512
-    void $ action' bs
-    readTilEOF action' fd'
-
-
-actionWithPipes :: ((Fd, Fd) -> IO b) -> IO b
-actionWithPipes a =
-  createPipe >>= \(p1, p2) -> (flip finally) (cleanup [p1, p2]) $ a (p1, p2)
-
-cleanup :: [Fd] -> IO ()
-cleanup fds = for_ fds $ \fd -> handleIO (\_ -> pure ()) $ closeFd fd
-
-
-
--- | Create a new regular file in write-only mode. The file must not exist.
-createRegularFileFd :: FileMode -> Path b -> IO Fd
-createRegularFileFd fm dest =
-  FD.openFd (toFilePath dest) WriteOnly [oExcl] (Just fm)
-
-
--- | Thin wrapper around `executeFile`.
-exec :: ByteString       -- ^ thing to execute
-     -> Bool             -- ^ whether to search PATH for the thing
-     -> [ByteString]     -- ^ args for the thing
-     -> Maybe (Path Abs) -- ^ optionally chdir into this
-     -> Maybe [(ByteString, ByteString)] -- ^ optional environment
-     -> IO (Either ProcessError ())
-exec exe spath args chdir env = do
-  pid <- SPPB.forkProcess $ do
-    maybe (pure ()) (changeWorkingDirectory . toFilePath) chdir
-    SPPB.executeFile exe spath args env
-
-  fmap (toProcessError exe args) $ SPPB.getProcessStatus True True pid
-
-
-toProcessError :: ByteString
-               -> [ByteString]
-               -> Maybe ProcessStatus
-               -> Either ProcessError ()
-toProcessError exe args mps = case mps of
-  Just (SPPB.Exited (ExitFailure i)) -> Left $ NonZeroExit i exe args
-  Just (SPPB.Exited ExitSuccess    ) -> Right ()
-  Just (Terminated _ _             ) -> Left $ PTerminated exe args
-  Just (Stopped _                  ) -> Left $ PStopped exe args
-  Nothing                            -> Left $ NoSuchPid exe args
-
-
--- | Convert the String to a ByteString with the current
--- system encoding.
-unsafePathToString :: Path b -> IO FilePath
-unsafePathToString p = do
-  enc <- getLocaleEncoding
-  unsafeUseAsCStringLen (toFilePath p) (peekCStringLen enc)
-
-
--- | Search for a file in the search paths.
---
--- Catches `PermissionDenied` and `NoSuchThing` and returns `Nothing`.
-searchPath :: [Path Abs] -> Path Rel -> IO (Maybe (Path Abs))
-searchPath paths needle = go paths
- where
-  go [] = pure Nothing
-  go (x : xs) =
-    hideErrorDefM PermissionDenied (go xs)
-      $ hideErrorDefM NoSuchThing (go xs)
-      $ do
-          dirStream <- openDirStream (toFilePath x)
-          S.findM (\(_, p) -> isMatch x p) (dirContentsStream dirStream)
-            >>= \case
-                  Just _  -> pure $ Just (x </> needle)
-                  Nothing -> go xs
-  isMatch basedir p = do
-    if p == toFilePath needle
-      then isExecutable (basedir </> needle)
-      else pure False
+import GHCup.Utils.File.Common
+#if IS_WINDOWS
+import GHCup.Utils.File.Windows
+#else
+import GHCup.Utils.File.Posix
+#endif

lib/GHCup/Utils/File/Common.hs

@@ -0,0 +1,106 @@
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE ViewPatterns      #-}
+
+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           GHC.IO.Exception
+import           Optics                  hiding ((<|), (|>))
+import           System.Directory
+import           System.FilePath
+import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
+import           Text.Regex.Posix
+
+import qualified Data.ByteString.Lazy          as BL
+
+
+
+data ProcessError = NonZeroExit Int FilePath [String]
+                  | PTerminated FilePath [String]
+                  | PStopped FilePath [String]
+                  | NoSuchPid FilePath [String]
+                  deriving Show
+
+instance Pretty ProcessError where
+  pPrint (NonZeroExit e exe args) =
+    text [i|Process "#{exe}" with arguments #{args} failed with exit code #{e}.|]
+  pPrint (PTerminated exe args) =
+    text [i|Process "#{exe}" with arguments #{args} terminated.|]
+  pPrint (PStopped exe args) =
+    text [i|Process "#{exe}" with arguments #{args} stopped.|]
+  pPrint (NoSuchPid exe args) =
+    text [i|Could not find PID for process running "#{exe}" with arguments #{args}.|]
+
+data CapturedProcess = CapturedProcess
+  { _exitCode :: ExitCode
+  , _stdOut   :: BL.ByteString
+  , _stdErr   :: BL.ByteString
+  }
+  deriving (Eq, Show)
+
+makeLenses ''CapturedProcess
+
+
+
+-- | Search for a file in the search paths.
+--
+-- Catches `PermissionDenied` and `NoSuchThing` and returns `Nothing`.
+searchPath :: [FilePath] -> FilePath -> IO (Maybe FilePath)
+searchPath paths needle = go paths
+ where
+  go [] = pure Nothing
+  go (x : xs) =
+    hideErrorDefM [InappropriateType, PermissionDenied, NoSuchThing] (go xs)
+      $ do
+          contents <- listDirectory x
+          findM (isMatch x) contents >>= \case
+            Just _ -> pure $ Just (x </> needle)
+            Nothing -> go xs
+  isMatch basedir p = do
+    if p == needle
+      then isExecutable (basedir </> needle)
+      else pure False
+
+  isExecutable :: FilePath -> IO Bool
+  isExecutable file = executable <$> getPermissions file
+
+
+-- | Check wether a binary is shadowed by another one that comes before
+-- it in PATH. Returns the path to said binary, if any.
+isShadowed :: FilePath -> IO (Maybe FilePath)
+isShadowed p = do
+  let dir = takeDirectory p
+  let fn = takeFileName p
+  spaths <- liftIO getSearchPath
+  if dir `elem` spaths
+  then do
+    let shadowPaths = takeWhile (/= dir) spaths
+    searchPath shadowPaths fn
+  else pure Nothing
+
+
+-- | Check whether the binary is in PATH. This returns only `True`
+-- if the directory containing the binary is part of PATH.
+isInPath :: FilePath -> IO Bool
+isInPath p = do
+  let dir = takeDirectory p
+  let fn = takeFileName p
+  spaths <- liftIO getSearchPath
+  if dir `elem` spaths
+  then isJust <$> searchPath [dir] fn
+  else pure False
+
+
+findFiles :: FilePath -> Regex -> IO [FilePath]
+findFiles path regex = do
+  contents <- listDirectory path
+  pure $ filter (match regex) contents
+

lib/GHCup/Utils/File/Posix.hs

@@ -0,0 +1,386 @@
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE ViewPatterns      #-}
+
+{-|
+Module      : GHCup.Utils.File.Posix
+Description : File and unix APIs
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : POSIX
+
+This module handles file and executable handling.
+Some of these functions use sophisticated logging.
+-}
+module GHCup.Utils.File.Posix where
+
+import           GHCup.Utils.File.Common
+import           GHCup.Utils.Prelude
+import           GHCup.Types
+
+import           Control.Concurrent
+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
+import           System.Console.Pretty   hiding ( Pretty )
+import           System.Console.Regions
+import           System.IO.Error
+import           System.FilePath
+import           System.Directory
+import           System.Posix.Directory
+import           System.Posix.Files
+import           System.Posix.IO
+import           System.Posix.Process           ( ProcessStatus(..) )
+import           System.Posix.Types
+
+
+import qualified Control.Exception             as EX
+import qualified Data.Sequence                 as Sq
+import qualified Data.Text                     as T
+import qualified Data.Text.Encoding            as E
+import qualified System.Posix.Process          as SPP
+import qualified Data.ByteString               as BS
+import qualified Data.ByteString.Lazy          as BL
+import qualified "unix-bytestring" System.Posix.IO.ByteString
+                                               as SPIB
+
+
+
+-- | Execute the given command and collect the stdout, stderr and the exit code.
+-- The command is run in a subprocess.
+executeOut :: MonadIO m
+           => FilePath          -- ^ command as filename, e.g. 'ls'
+           -> [String]          -- ^ arguments to the command
+           -> Maybe FilePath    -- ^ chdir to this path
+           -> m CapturedProcess
+executeOut path args chdir = liftIO $ captureOutStreams $ do
+  maybe (pure ()) changeWorkingDirectory chdir
+  SPP.executeFile path True args Nothing
+
+
+execLogged :: (MonadReader AppState m, MonadIO m, MonadThrow m)
+           => FilePath         -- ^ thing to execute
+           -> [String]         -- ^ args for the thing
+           -> Maybe FilePath   -- ^ optionally chdir into this
+           -> FilePath         -- ^ log filename (opened in append mode)
+           -> Maybe [(String, String)] -- ^ optional environment
+           -> m (Either ProcessError ())
+execLogged exe args chdir lfile env = do
+  AppState { settings = Settings {..}, dirs = Dirs {..} } <- ask
+  let logfile = logsDir </> lfile <> ".log"
+  liftIO $ bracket (openFd logfile WriteOnly (Just newFilePerms) defaultFileFlags{ append = True })
+                   closeFd
+                   (action verbose)
+ where
+  action verbose fd = do
+    actionWithPipes $ \(stdoutRead, stdoutWrite) -> do
+      -- start the thread that logs to stdout
+      pState <- newEmptyMVar
+      done   <- newEmptyMVar
+      void
+        $ forkIO
+        $ EX.handle (\(_ :: IOException) -> pure ())
+        $ EX.finally
+            (if verbose
+              then tee fd stdoutRead
+              else printToRegion fd stdoutRead 6 pState
+            )
+            (putMVar done ())
+
+      -- fork the subprocess
+      pid <- SPP.forkProcess $ do
+        void $ dupTo stdoutWrite stdOutput
+        void $ dupTo stdoutWrite stdError
+        closeFd stdoutRead
+        closeFd stdoutWrite
+
+        -- execute the action
+        maybe (pure ()) changeWorkingDirectory chdir
+        void $ SPP.executeFile exe (not ("./" `isPrefixOf` exe)) args env
+
+      closeFd stdoutWrite
+
+      -- wait for the subprocess to finish
+      e <- toProcessError exe args <$!> SPP.getProcessStatus True True pid
+      putMVar pState (either (const False) (const True) e)
+
+      void $ race (takeMVar done) (threadDelay (1000000 * 3))
+      closeFd stdoutRead
+
+      pure e
+
+  tee :: Fd -> Fd -> IO ()
+  tee fileFd fdIn = readTilEOF lineAction fdIn
+
+   where
+    lineAction :: ByteString -> IO ()
+    lineAction bs' = do
+      void $ SPIB.fdWrite fileFd (bs' <> "\n")
+      void $ SPIB.fdWrite stdOutput (bs' <> "\n")
+
+  -- Reads fdIn and logs the output in a continous scrolling area
+  -- of 'size' terminal lines. Also writes to a log file.
+  printToRegion :: Fd -> Fd -> Int -> MVar Bool -> IO ()
+  printToRegion fileFd fdIn size pState = do
+    void $ displayConsoleRegions $ do
+      rs <-
+        liftIO
+        . fmap Sq.fromList
+        . sequence
+        . replicate size
+        . openConsoleRegion
+        $ Linear
+      flip runStateT mempty
+        $ handle
+            (\(ex :: SomeException) -> do
+              ps <- liftIO $ takeMVar pState
+              when ps (forM_ rs (liftIO . closeConsoleRegion))
+              throw ex
+            )
+        $ readTilEOF (lineAction rs) fdIn
+
+   where
+    -- action to perform line by line
+    -- TODO: do this with vty for efficiency
+    lineAction :: (MonadMask m, MonadIO m)
+               => Seq ConsoleRegion
+               -> ByteString
+               -> StateT (Seq ByteString) m ()
+    lineAction rs = \bs' -> do
+      void $ liftIO $ SPIB.fdWrite fileFd (bs' <> "\n")
+      modify (swapRegs bs')
+      regs <- get
+      liftIO $ forM_ (Sq.zip regs rs) $ \(bs, r) -> setConsoleRegion r $ do
+        w <- consoleWidth
+        return
+          . T.pack
+          . color Blue
+          . T.unpack
+          . decUTF8Safe
+          . trim w
+          . (\b -> "[ " <> E.encodeUtf8 (T.pack lfile) <> " ] " <> b)
+          $ bs
+
+    swapRegs :: a -> Seq a -> Seq a
+    swapRegs bs = \regs -> if
+      | Sq.length regs < size -> regs |> bs
+      | otherwise             -> Sq.drop 1 regs |> bs
+
+    -- trim output line to terminal width
+    trim :: Int -> ByteString -> ByteString
+    trim w = \bs -> if
+      | BS.length bs > w && w > 5 -> BS.take (w - 4) bs <> "..."
+      | otherwise                 -> bs
+
+  -- Consecutively read from Fd in 512 chunks until we hit
+  -- newline or EOF.
+  readLine :: MonadIO m
+           => Fd          -- ^ input file descriptor
+           -> ByteString  -- ^ rest buffer (read across newline)
+           -> m (ByteString, ByteString, Bool) -- ^ (full line, rest, eof)
+  readLine fd = go
+   where
+    go inBs = do
+      -- if buffer is not empty, process it first
+      mbs <- if BS.length inBs == 0
+               -- otherwise attempt read
+               then liftIO
+                    $ handleIO (\e -> if isEOFError e then pure Nothing else ioError e)
+                    $ fmap Just
+                    $ SPIB.fdRead fd 512
+               else pure $ Just inBs
+      case mbs of
+        Nothing -> pure ("", "", True)
+        Just bs -> do
+          -- split on newline
+          let (line, rest) = BS.span (/= _lf) bs
+          if
+            | BS.length rest /= 0 -> pure (line, BS.tail rest, False)
+            -- if rest is empty, then there was no newline, process further
+            | otherwise           -> (\(l, r, b) -> (line <> l, r, b)) <$!> go mempty
+
+  readTilEOF :: MonadIO m => (ByteString -> m a) -> Fd -> m ()
+  readTilEOF ~action' fd' = go mempty
+   where
+    go bs' = do
+      (bs, rest, eof) <- readLine fd' bs'
+      if eof
+         then liftIO $ ioError (mkIOError eofErrorType "" Nothing Nothing)
+         else void (action' bs) >> go rest
+
+
+-- | Capture the stdout and stderr of the given action, which
+-- is run in a subprocess. Stdin is closed. You might want to
+-- 'race' this to make sure it terminates.
+captureOutStreams :: IO a
+                     -- ^ the action to execute in a subprocess
+                  -> IO CapturedProcess
+captureOutStreams action = do
+  actionWithPipes $ \(parentStdoutRead, childStdoutWrite) ->
+    actionWithPipes $ \(parentStderrRead, childStderrWrite) -> do
+      pid <- SPP.forkProcess $ do
+        -- dup stdout
+        void $ dupTo childStdoutWrite stdOutput
+        closeFd childStdoutWrite
+        closeFd parentStdoutRead
+
+        -- dup stderr
+        void $ dupTo childStderrWrite stdError
+        closeFd childStderrWrite
+        closeFd parentStderrRead
+
+        -- execute the action
+        a <- action
+        void $ evaluate a
+
+      -- close everything we don't need
+      closeFd childStdoutWrite
+      closeFd childStderrWrite
+
+      -- start thread that writes the output
+      refOut <- newIORef BL.empty
+      refErr <- newIORef BL.empty
+      done   <- newEmptyMVar
+      _      <-
+        forkIO
+        $ EX.handle (\(_ :: IOException) -> pure ())
+        $ flip EX.finally (putMVar done ())
+        $ writeStds parentStdoutRead parentStderrRead refOut refErr
+
+      status <- SPP.getProcessStatus True True pid
+      void $ race (takeMVar done) (threadDelay (1000000 * 3))
+
+      case status of
+        -- readFd will take care of closing the fd
+        Just (SPP.Exited es) -> do
+          stdout' <- readIORef refOut
+          stderr' <- readIORef refErr
+          pure $ CapturedProcess { _exitCode = es
+                                 , _stdOut   = stdout'
+                                 , _stdErr   = stderr'
+                                 }
+
+        _ -> throwIO $ userError ("No such PID " ++ show pid)
+
+ where
+  writeStds :: Fd -> Fd -> IORef BL.ByteString -> IORef BL.ByteString -> IO ()
+  writeStds pout perr rout rerr = do
+    doneOut <- newEmptyMVar
+    void
+      $ forkIO
+      $ hideError eofErrorType
+      $ flip EX.finally (putMVar doneOut ())
+      $ readTilEOF (\x -> modifyIORef' rout (<> BL.fromStrict x)) pout
+    doneErr <- newEmptyMVar
+    void
+      $ forkIO
+      $ hideError eofErrorType
+      $ flip EX.finally (putMVar doneErr ())
+      $ readTilEOF (\x -> modifyIORef' rerr (<> BL.fromStrict x)) perr
+    takeMVar doneOut
+    takeMVar doneErr
+
+  readTilEOF ~action' fd' = do
+    bs <- SPIB.fdRead fd' 512
+    void $ action' bs
+    readTilEOF action' fd'
+
+
+actionWithPipes :: ((Fd, Fd) -> IO b) -> IO b
+actionWithPipes a =
+  createPipe >>= \(p1, p2) -> flip finally (cleanup [p1, p2]) $ a (p1, p2)
+
+cleanup :: [Fd] -> IO ()
+cleanup fds = for_ fds $ \fd -> handleIO (\_ -> pure ()) $ closeFd fd
+
+
+
+-- | Create a new regular file in write-only mode. The file must not exist.
+createRegularFileFd :: FileMode -> FilePath -> IO Fd
+createRegularFileFd fm dest =
+  openFd dest WriteOnly (Just fm) defaultFileFlags{ exclusive = True }
+
+
+-- | Thin wrapper around `executeFile`.
+exec :: MonadIO m
+     => String           -- ^ thing to execute
+     -> [String]         -- ^ args for the thing
+     -> Maybe FilePath   -- ^ optionally chdir into this
+     -> Maybe [(String, String)] -- ^ optional environment
+     -> m (Either ProcessError ())
+exec exe args chdir env = liftIO $ do
+  pid <- SPP.forkProcess $ do
+    maybe (pure ()) changeWorkingDirectory chdir
+    SPP.executeFile exe (not ("./" `isPrefixOf` exe)) args env
+
+  fmap (toProcessError exe args) $ SPP.getProcessStatus True True pid
+
+
+toProcessError :: FilePath
+               -> [String]
+               -> Maybe ProcessStatus
+               -> Either ProcessError ()
+toProcessError exe args mps = case mps of
+  Just (SPP.Exited (ExitFailure xi)) -> Left $ NonZeroExit xi exe args
+  Just (SPP.Exited ExitSuccess    ) -> Right ()
+  Just (Terminated _ _             ) -> Left $ PTerminated exe args
+  Just (Stopped _                  ) -> Left $ PStopped exe args
+  Nothing                            -> Left $ NoSuchPid exe args
+
+
+
+chmod_755 :: (MonadLogger m, MonadIO m) => FilePath -> m ()
+chmod_755 fp = do
+  let exe_mode =
+          nullFileMode
+            `unionFileModes` ownerExecuteMode
+            `unionFileModes` ownerReadMode
+            `unionFileModes` ownerWriteMode
+            `unionFileModes` groupExecuteMode
+            `unionFileModes` groupReadMode
+            `unionFileModes` otherExecuteMode
+            `unionFileModes` otherReadMode
+  $(logDebug) [i|chmod 755 #{fp}|]
+  liftIO $ setFileMode fp exe_mode
+
+
+-- |Default permissions for a new file.
+newFilePerms :: FileMode
+newFilePerms =
+  ownerWriteMode
+    `unionFileModes` ownerReadMode
+    `unionFileModes` groupWriteMode
+    `unionFileModes` groupReadMode
+    `unionFileModes` otherWriteMode
+    `unionFileModes` otherReadMode
+
+
+-- | Checks whether the binary is a broken link.
+isBrokenSymlink :: FilePath -> IO Bool
+isBrokenSymlink fp = do
+  try (pathIsSymbolicLink fp) >>= \case
+    Right True -> do
+      let symDir = takeDirectory fp
+      tfp <- getSymbolicLinkTarget fp
+      not <$> doesPathExist
+        -- this drops 'symDir' if 'tfp' is absolute
+        (symDir </> tfp)
+    Right b -> pure b
+    Left e | isDoesNotExistError e -> pure False
+           | otherwise -> throwIO e

lib/GHCup/Utils/File/Windows.hs

@@ -0,0 +1,240 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE FlexibleContexts  #-}
+
+{-|
+Module      : GHCup.Utils.File.Windows
+Description : File and windows APIs
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : Windows
+
+This module handles file and executable handling.
+Some of these functions use sophisticated logging.
+-}
+module GHCup.Utils.File.Windows where
+
+import {-# SOURCE #-} GHCup.Utils ( getLinkTarget, pathIsLink )
+import           GHCup.Utils.Dirs
+import           GHCup.Utils.File.Common
+import           GHCup.Types
+
+import           Control.Concurrent
+import           Control.DeepSeq
+import           Control.Exception.Safe
+import           Control.Monad
+import           Control.Monad.Reader
+import           Data.List
+import           Foreign.C.Error
+import           GHC.IO.Exception
+import           GHC.IO.Handle
+import           System.Directory
+import           System.Environment
+import           System.FilePath
+import           System.IO
+import           System.Process
+ 
+import qualified Control.Exception             as EX
+import qualified Data.ByteString               as BS
+import qualified Data.ByteString.Lazy          as BL
+import qualified Data.Map.Strict               as Map
+
+
+
+toProcessError :: FilePath
+               -> [FilePath]
+               -> ExitCode
+               -> Either ProcessError ()
+toProcessError exe args exitcode = case exitcode of
+  (ExitFailure xi) -> Left $ NonZeroExit xi exe args
+  ExitSuccess -> Right ()
+
+
+-- | @readCreateProcessWithExitCode@ works exactly like 'readProcessWithExitCode' except that it
+-- lets you pass 'CreateProcess' giving better flexibility.
+--
+-- Note that @Handle@s provided for @std_in@, @std_out@, or @std_err@ via the CreateProcess
+-- record will be ignored.
+--
+-- @since 1.2.3.0
+readCreateProcessWithExitCodeBS
+    :: CreateProcess
+    -> BL.ByteString
+    -> IO (ExitCode, BL.ByteString, BL.ByteString) -- ^ exitcode, stdout, stderr
+readCreateProcessWithExitCodeBS cp input = do
+    let cp_opts = cp {
+                    std_in  = CreatePipe,
+                    std_out = CreatePipe,
+                    std_err = CreatePipe
+                  }
+    withCreateProcess_ "readCreateProcessWithExitCodeBS" cp_opts $
+      \mb_inh mb_outh mb_errh ph ->
+        case (mb_inh, mb_outh, mb_errh) of
+          (Just inh, Just outh, Just errh) -> do
+
+            out <- BS.hGetContents outh
+            err <- BS.hGetContents errh
+
+            -- fork off threads to start consuming stdout & stderr
+            withForkWait  (EX.evaluate $ rnf out) $ \waitOut ->
+             withForkWait (EX.evaluate $ rnf err) $ \waitErr -> do
+
+              -- now write any input
+              unless (BL.null input) $
+                ignoreSigPipe $ BL.hPut inh input
+              -- hClose performs implicit hFlush, and thus may trigger a SIGPIPE
+              ignoreSigPipe $ hClose inh
+
+              -- wait on the output
+              waitOut
+              waitErr
+
+              hClose outh
+              hClose errh
+
+            -- wait on the process
+            ex <- waitForProcess ph
+            return (ex, BL.fromStrict out, BL.fromStrict err)
+
+          (Nothing,_,_) -> error "readCreateProcessWithExitCodeBS: Failed to get a stdin handle."
+          (_,Nothing,_) -> error "readCreateProcessWithExitCodeBS: Failed to get a stdout handle."
+          (_,_,Nothing) -> error "readCreateProcessWithExitCodeBS: Failed to get a stderr handle."
+ where
+  ignoreSigPipe :: IO () -> IO ()
+  ignoreSigPipe = EX.handle $ \e -> case e of
+                                     IOError { ioe_type  = ResourceVanished
+                                             , ioe_errno = Just ioe }
+                                       | Errno ioe == ePIPE -> return ()
+                                     _ -> throwIO e
+  -- wrapper so we can get exceptions with the appropriate function name.
+  withCreateProcess_
+    :: String
+    -> CreateProcess
+    -> (Maybe Handle -> Maybe Handle -> Maybe Handle -> ProcessHandle -> IO a)
+    -> IO a
+  withCreateProcess_ fun c action =
+      EX.bracketOnError (createProcess_ fun c) cleanupProcess
+                       (\(m_in, m_out, m_err, ph) -> action m_in m_out m_err ph)
+
+-- | Fork a thread while doing something else, but kill it if there's an
+-- exception.
+--
+-- This is important in the cases above because we want to kill the thread
+-- that is holding the Handle lock, because when we clean up the process we
+-- try to close that handle, which could otherwise deadlock.
+--
+withForkWait :: IO () -> (IO () ->  IO a) -> IO a
+withForkWait async' body = do
+  waitVar <- newEmptyMVar :: IO (MVar (Either SomeException ()))
+  mask $ \restore -> do
+    tid <- forkIO $ try (restore async') >>= putMVar waitVar
+    let wait' = takeMVar waitVar >>= either throwIO return
+    restore (body wait') `EX.onException` killThread tid
+
+
+-- | Execute the given command and collect the stdout, stderr and the exit code.
+-- The command is run in a subprocess.
+executeOut :: MonadIO m
+           => FilePath          -- ^ command as filename, e.g. 'ls'
+           -> [String]          -- ^ arguments to the command
+           -> Maybe FilePath    -- ^ chdir to this path
+           -> m CapturedProcess
+executeOut path args chdir = do
+  cp <- createProcessWithMingwPath ((proc path args){ cwd = chdir })
+  (exit, out, err) <- liftIO $ readCreateProcessWithExitCodeBS cp ""
+  pure $ CapturedProcess exit out err
+
+
+execLogged :: (MonadReader AppState m, MonadIO m, MonadThrow m)
+           => FilePath         -- ^ thing to execute
+           -> [String]         -- ^ args for the thing
+           -> Maybe FilePath   -- ^ optionally chdir into this
+           -> FilePath         -- ^ log filename (opened in append mode)
+           -> Maybe [(String, String)] -- ^ optional environment
+           -> m (Either ProcessError ())
+execLogged exe args chdir lfile env = do
+  AppState { dirs = Dirs {..} } <- ask
+  let stdoutLogfile = logsDir </> lfile <> ".stdout.log"
+      stderrLogfile = logsDir </> lfile <> ".stderr.log"
+  cp <- createProcessWithMingwPath ((proc exe args)
+    { cwd = chdir
+    , env = env
+    , std_in = CreatePipe
+    , std_out = CreatePipe
+    , std_err = CreatePipe
+    })
+  fmap (toProcessError exe args)
+    $ liftIO
+    $ withCreateProcess cp
+    $ \_ mout merr ph ->
+        case (mout, merr) of
+          (Just cStdout, Just cStderr) -> do
+            withForkWait (tee stdoutLogfile cStdout) $ \waitOut ->
+              withForkWait (tee stderrLogfile cStderr) $ \waitErr -> do
+                waitOut
+                waitErr
+            waitForProcess ph
+          _ -> fail "Could not acquire out/err handle"
+
+ where
+  tee :: FilePath -> Handle -> IO ()
+  tee logFile handle' = go
+    where
+      go = do
+        some <- BS.hGetSome handle' 512
+        if BS.null some
+          then pure ()
+          else do
+            void $ BS.appendFile logFile some
+            void $ BS.hPut stdout some
+            go
+        
+
+-- | Thin wrapper around `executeFile`.
+exec :: MonadIO m
+     => FilePath       -- ^ thing to execute
+     -> [FilePath]     -- ^ args for the thing
+     -> Maybe FilePath   -- ^ optionally chdir into this
+     -> Maybe [(String, String)] -- ^ optional environment
+     -> m (Either ProcessError ())
+exec exe args chdir env = do
+  cp <- createProcessWithMingwPath ((proc exe args) { cwd = chdir, env = env })
+  exit_code <- liftIO $ withCreateProcess cp $ \_ _ _ p -> waitForProcess p
+  pure $ toProcessError exe args exit_code
+
+
+chmod_755 :: MonadIO m => FilePath -> m ()
+chmod_755 fp =
+  let perm = setOwnerWritable True emptyPermissions
+  in liftIO $ setPermissions fp perm
+
+
+createProcessWithMingwPath :: MonadIO m
+                          => CreateProcess
+                          -> m CreateProcess
+createProcessWithMingwPath cp = do
+  baseDir <- liftIO ghcupBaseDir
+  cEnv <- Map.fromList <$> maybe (liftIO getEnvironment) pure (env cp)
+  let mingWPaths = [baseDir </> "msys64" </> "usr" </> "bin"
+                   ,baseDir </> "msys64" </> "mingw64" </> "bin"]
+      paths = ["PATH", "Path"]
+      curPaths = (\x -> maybe [] splitSearchPath (Map.lookup x cEnv)) =<< paths
+      newPath = intercalate [searchPathSeparator] (mingWPaths ++ curPaths)
+      envWithoutPath = foldr (\x y -> Map.delete x y) cEnv paths
+      envWithNewPath = Map.insert "Path" newPath envWithoutPath
+  liftIO $ setEnv "Path" newPath
+  pure $ cp { env = Just $ Map.toList envWithNewPath }
+
+
+-- | Checks whether the binary is a broken link.
+isBrokenSymlink :: FilePath -> IO Bool
+isBrokenSymlink fp = do
+  b <- pathIsLink fp
+  if b
+  then do
+    tfp <- getLinkTarget fp
+    not <$> doesPathExist
+      -- this drops 'symDir' if 'tfp' is absolute
+      (takeDirectory fp </> tfp)
+  else pure False

lib/GHCup/Utils/Logger.hs

@@ -1,18 +1,34 @@
-{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE QuasiQuotes      #-}
 
+{-|
+Module      : GHCup.Utils.Logger
+Description : logger definition
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+
+Here we define our main logger.
+-}
 module GHCup.Utils.Logger where
 
-import           GHCup.Utils
+import           GHCup.Utils.File
+import           GHCup.Utils.String.QQ
 
 import           Control.Monad
+import           Control.Monad.IO.Class
 import           Control.Monad.Logger
-import           HPath
-import           HPath.IO
 import           Prelude                 hiding ( appendFile )
 import           System.Console.Pretty
+import           System.Directory        hiding ( findFiles )
+import           System.FilePath
 import           System.IO.Error
+import           Text.Regex.Posix
 
 import qualified Data.ByteString               as B
+import GHCup.Utils.Prelude
 
 
 data LoggerConfig = LoggerConfig
@@ -36,7 +52,7 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
           LevelOther t -> toLogStr "[ " <> toLogStr t <> toLogStr " ]"
     let out = fromLogStr (l <> toLogStr " " <> str' <> toLogStr "\n")
 
-    when (lcPrintDebug || (lcPrintDebug == False && not (level == LevelDebug)))
+    when (lcPrintDebug || (not lcPrintDebug && (level /= LevelDebug)))
       $ colorOutter out
 
     -- raw output
@@ -50,11 +66,18 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
     rawOutter outr
 
 
-initGHCupFileLogging :: Path Rel -> IO (Path Abs)
-initGHCupFileLogging context = do
-  logs <- ghcupLogsDir
-  let logfile = logs </> context
-  createDirIfMissing newDirPerms logs
-  hideError doesNotExistErrorType $ deleteFile logfile
-  createRegularFile newFilePerms logfile
-  pure logfile
+initGHCupFileLogging :: (MonadIO m) => FilePath -> m FilePath
+initGHCupFileLogging logsDir = do
+  let logfile = logsDir </> "ghcup.log"
+  liftIO $ do
+    createDirectoryIfMissing True logsDir
+    logFiles <- findFiles
+      logsDir
+      (makeRegexOpts compExtended
+                     execBlank
+                     ([s|^.*\.log$|] :: B.ByteString)
+      )
+    forM_ logFiles $ hideError doesNotExistErrorType . rmFile . (logsDir </>)
+
+    writeFile logfile ""
+    pure logfile

lib/GHCup/Utils/MegaParsec.hs

@@ -0,0 +1,124 @@
+{-# LANGUAGE CPP                  #-}
+{-# LANGUAGE OverloadedStrings    #-}
+
+{-|
+Module      : GHCup.Utils.MegaParsec
+Description : MegaParsec utilities
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+-}
+module GHCup.Utils.MegaParsec where
+
+import           GHCup.Types
+
+import           Control.Applicative
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Data.Functor
+import           Data.Maybe
+import           Data.Text                      ( Text )
+import           Data.Versions
+import           Data.Void
+import           System.FilePath
+
+import qualified Data.List.NonEmpty            as NE
+import qualified Data.Text                     as T
+import qualified Text.Megaparsec               as MP
+
+
+choice' :: (MonadFail f, MP.MonadParsec e s f) => [f a] -> f a
+choice' []       = fail "Empty list"
+choice' [x     ] = x
+choice' (x : xs) = MP.try x <|> choice' xs
+
+
+parseUntil :: MP.Parsec Void Text a -> MP.Parsec Void Text Text
+parseUntil p = do
+  (MP.try (MP.lookAhead p) $> mempty)
+    <|> (do
+          c  <- T.singleton <$> MP.anySingle
+          c2 <- parseUntil p
+          pure (c `mappend` c2)
+        )
+
+parseUntil1 :: MP.Parsec Void Text a -> MP.Parsec Void Text Text
+parseUntil1 p = do
+  i1 <- MP.getOffset
+  t <- parseUntil p
+  i2 <- MP.getOffset
+  if i1 == i2 then fail "empty parse" else pure t
+
+
+
+-- | Parses e.g.
+--   * armv7-unknown-linux-gnueabihf-ghc
+--   * armv7-unknown-linux-gnueabihf-ghci
+ghcTargetBinP :: Text -> MP.Parsec Void Text (Maybe Text, Text)
+ghcTargetBinP t =
+  (,)
+    <$> (   MP.try
+            (Just <$> parseUntil1 (MP.chunk "-" *> MP.chunk t) <* MP.chunk "-"
+            )
+        <|> ((\ _ x -> x) Nothing <$> mempty)
+        )
+    <*> (MP.chunk t <* MP.eof)
+
+
+-- | Extracts the version from @ProjectVersion="8.10.5"@.
+ghcProjectVersion :: MP.Parsec Void Text Version
+ghcProjectVersion = do
+  _ <- MP.chunk "ProjectVersion=\""
+  ver <- parseUntil1 $ MP.chunk "\""
+  MP.setInput ver
+  version'
+
+
+-- | Extracts target triple and version from e.g.
+--   * armv7-unknown-linux-gnueabihf-8.8.3
+--   * armv7-unknown-linux-gnueabihf-8.8.3
+ghcTargetVerP :: MP.Parsec Void Text GHCTargetVersion
+ghcTargetVerP =
+  (\x y -> GHCTargetVersion x y)
+    <$> (MP.try (Just <$> parseUntil1 (MP.chunk "-" *> verP') <* MP.chunk "-")
+        <|> ((\ _ x -> x) Nothing <$> mempty)
+        )
+    <*> (version' <* MP.eof)
+ where
+  verP' :: MP.Parsec Void Text Text
+  verP' = do
+    v <- version'
+    let startsWithDigists =
+          and
+            . take 3
+            . concatMap
+              (map
+                (\case
+                  (Digits _) -> True
+                  (Str    _) -> False
+                ) . NE.toList)
+            . NE.toList
+            $ _vChunks v
+    if startsWithDigists && isNothing (_vEpoch v)
+      then pure $ prettyVer v
+      else fail "Oh"
+
+
+verP :: MP.Parsec Void Text Text -> MP.Parsec Void Text Versioning
+verP suffix = do
+  ver <- parseUntil suffix
+  if T.null ver
+    then fail "empty version"
+    else do
+      rest <- MP.getInput
+      MP.setInput ver
+      v <- versioning'
+      MP.setInput rest
+      pure v
+
+
+pathSep :: MP.Parsec Void Text Char
+pathSep = MP.oneOf pathSeparators

lib/GHCup/Utils/Prelude.hs

@@ -1,13 +1,22 @@
+{-# LANGUAGE CPP                 #-}
 {-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE DeriveLift          #-}
 {-# LANGUAGE FlexibleContexts    #-}
 {-# LANGUAGE FlexibleInstances   #-}
-{-# LANGUAGE QuasiQuotes         #-}
 {-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeApplications    #-}
 {-# LANGUAGE TypeFamilies        #-}
 {-# LANGUAGE TypeOperators       #-}
 
+{-|
+Module      : GHCup.Utils.Prelude
+Description : MegaParsec utilities
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+
+GHCup specific prelude. Lots of Excepts functionality.
+-}
 module GHCup.Utils.Prelude where
 
 import           Control.Applicative
@@ -17,18 +26,30 @@ import           Control.Monad.IO.Class
 import           Control.Monad.Trans.Class      ( lift )
 import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
+import           Data.List                      ( nub )
+import           Data.Foldable
 import           Data.String
 import           Data.Text                      ( Text )
 import           Data.Versions
+import           Data.Word8
 import           Haskus.Utils.Types.List
 import           Haskus.Utils.Variant.Excepts
 import           System.IO.Error
-import           System.Posix.Env.ByteString    ( getEnvironment )
+import           System.IO.Unsafe
+import           System.Directory
+import           System.FilePath
 
+#if defined(IS_WINDOWS)
+import           Control.Retry
+import           GHC.IO.Exception
+#endif
+
+import qualified Data.ByteString               as B
 import qualified Data.ByteString.Lazy          as L
 import qualified Data.Strict.Maybe             as S
 import qualified Data.Text                     as T
 import qualified Data.Text.Encoding            as E
+import qualified Data.Text.Encoding.Error      as E
 import qualified Data.Text.Lazy                as TL
 import qualified Data.Text.Lazy.Builder        as B
 import qualified Data.Text.Lazy.Builder.Int    as B
@@ -87,10 +108,6 @@ whileM_ ~action = void . whileM action
 guardM :: (Monad m, Alternative m) => m Bool -> m ()
 guardM ~f = guard =<< f
 
-lBS2sT :: L.ByteString -> Text
-lBS2sT = TL.toStrict . TLE.decodeUtf8
-
-
 
 handleIO' :: (MonadIO m, MonadCatch m)
           => IOErrorType
@@ -121,7 +138,7 @@ lE' :: forall e' e es a m
     => (e' -> e)
     -> Either e' a
     -> Excepts es m a
-lE' f = liftE . veitherToExcepts . fromEither . bimap f id
+lE' f = liftE . veitherToExcepts . fromEither . first f
 
 lEM :: forall e es a m . (Monad m, e :< es) => m (Either e a) -> Excepts es m a
 lEM em = lift em >>= lE
@@ -131,7 +148,7 @@ lEM' :: forall e' e es a m
      => (e' -> e)
      -> m (Either e' a)
      -> Excepts es m a
-lEM' f em = lift em >>= lE . bimap f id
+lEM' f em = lift em >>= lE . first f
 
 fromEither :: Either a b -> VEither '[a] b
 fromEither = either (VLeft . V) VRight
@@ -168,14 +185,19 @@ liftIOException errType ex =
     . lift
 
 
-hideErrorDef :: IOErrorType -> a -> IO a -> IO a
-hideErrorDef err def =
-  handleIO (\e -> if err == ioeGetErrorType e then pure def else ioError e)
+-- | Uses safe-exceptions.
+hideError :: (MonadIO m, MonadCatch m) => IOErrorType -> m () -> m ()
+hideError err = handleIO (\e -> if err == ioeGetErrorType e then pure () else liftIO . ioError $ e)
 
 
-hideErrorDefM :: IOErrorType -> IO a -> IO a -> IO a
-hideErrorDefM err def =
-  handleIO (\e -> if err == ioeGetErrorType e then def else ioError e)
+hideErrorDef :: [IOErrorType] -> a -> IO a -> IO a
+hideErrorDef errs def =
+  handleIO (\e -> if ioeGetErrorType e `elem` errs then pure def else ioError e)
+
+
+hideErrorDefM :: [IOErrorType] -> IO a -> IO a -> IO a
+hideErrorDefM errs def =
+  handleIO (\e -> if ioeGetErrorType e `elem` errs then def else ioError e)
 
 
 -- TODO: does this work?
@@ -185,8 +207,8 @@ hideExcept :: forall e es es' a m
            -> a
            -> Excepts es m a
            -> Excepts es' m a
-hideExcept _ a action =
-  catchLiftLeft ((\_ -> pure a) :: (e -> Excepts es' m a)) action
+hideExcept _ a =
+  catchLiftLeft ((\_ -> pure a) :: (e -> Excepts es' m a))
 
 
 hideExcept' :: forall e es es' m
@@ -194,8 +216,8 @@ hideExcept' :: forall e es es' m
             => e
             -> Excepts es m ()
             -> Excepts es' m ()
-hideExcept' _ action =
-  catchLiftLeft ((\_ -> pure ()) :: (e -> Excepts es' m ())) action
+hideExcept' _ =
+  catchLiftLeft ((\_ -> pure ()) :: (e -> Excepts es' m ()))
 
 
 reThrowAll :: forall e es es' a m
@@ -221,9 +243,17 @@ throwEither a = case a of
   Right r -> pure r
 
 
+throwEither' :: (Exception a, MonadThrow m) => a -> Either x b -> m b
+throwEither' e eth = case eth of
+  Left  _ -> throwM e
+  Right r -> pure r
+
+
 verToBS :: Version -> ByteString
 verToBS = E.encodeUtf8 . prettyVer
 
+verToS :: Version -> String
+verToS = T.unpack . prettyVer
 
 intToText :: Integral a => a -> T.Text
 intToText = TL.toStrict . B.toLazyText . B.decimal
@@ -234,9 +264,163 @@ removeLensFieldLabel str' =
   maybe str' T.unpack . T.stripPrefix (T.pack "_") . T.pack $ str'
 
 
-addToCurrentEnv :: MonadIO m
-                => [(ByteString, ByteString)]
-                -> m [(ByteString, ByteString)]
-addToCurrentEnv adds = do
-  cEnv <- liftIO $ getEnvironment
-  pure (adds ++ cEnv)
+pvpToVersion :: PVP -> Version
+pvpToVersion =
+  either (\_ -> error "Couldn't convert PVP to Version") id
+    . version
+    . prettyPVP
+
+
+-- | Safe 'decodeUtf8With'. Replaces an invalid input byte with
+-- the Unicode replacement character U+FFFD.
+decUTF8Safe :: ByteString -> Text
+decUTF8Safe = E.decodeUtf8With E.lenientDecode
+
+decUTF8Safe' :: L.ByteString -> Text
+decUTF8Safe' = TL.toStrict . TLE.decodeUtf8With E.lenientDecode
+
+
+-- | Escape a version for use in regex
+escapeVerRex :: Version -> ByteString
+escapeVerRex = B.pack . go . B.unpack . verToBS
+ where
+  go [] = []
+  go (x : xs) | x == _period = [_backslash, _period] ++ go xs
+              | otherwise    = x : go xs
+
+-- | More permissive version of 'createDirRecursive'. This doesn't
+-- error when the destination is a symlink to a directory.
+createDirRecursive' :: FilePath -> IO ()
+createDirRecursive' p =
+  handleIO (\e -> if isAlreadyExistsError e then isSymlinkDir e else throwIO e)
+    . createDirectoryIfMissing True
+    $ p
+
+ where
+  isSymlinkDir e = do
+    ft <- pathIsSymbolicLink p
+    case ft of
+      True -> do
+        rp <- canonicalizePath p
+        rft <- doesDirectoryExist rp
+        case rft of
+          True -> pure ()
+          _ -> throwIO e
+      _ -> throwIO e
+
+
+-- | Recursively copy the contents of one directory to another path.
+--
+-- This is a rip-off of Cabal library.
+copyDirectoryRecursive :: FilePath -> FilePath -> IO ()
+copyDirectoryRecursive srcDir destDir = do
+  srcFiles <- getDirectoryContentsRecursive srcDir
+  copyFilesWith copyFile destDir [ (srcDir, f)
+                                   | f <- srcFiles ]
+  where
+    -- | Common implementation of 'copyFiles', 'installOrdinaryFiles',
+    -- 'installExecutableFiles' and 'installMaybeExecutableFiles'.
+    copyFilesWith :: (FilePath -> FilePath -> IO ())
+                  -> FilePath -> [(FilePath, FilePath)] -> IO ()
+    copyFilesWith doCopy targetDir srcFiles = do
+
+      -- Create parent directories for everything
+      let dirs = map (targetDir </>) . nub . map (takeDirectory . snd) $ srcFiles
+      traverse_ (createDirectoryIfMissing True) dirs
+
+      -- Copy all the files
+      sequence_ [ let src  = srcBase   </> srcFile
+                      dest = targetDir </> srcFile
+                   in doCopy src dest
+                | (srcBase, srcFile) <- srcFiles ]
+
+    -- | List all the files in a directory and all subdirectories.
+    --
+    -- The order places files in sub-directories after all the files in their
+    -- parent directories. The list is generated lazily so is not well defined if
+    -- the source directory structure changes before the list is used.
+    --
+    getDirectoryContentsRecursive :: FilePath -> IO [FilePath]
+    getDirectoryContentsRecursive topdir = recurseDirectories [""]
+      where
+        recurseDirectories :: [FilePath] -> IO [FilePath]
+        recurseDirectories []         = return []
+        recurseDirectories (dir:dirs) = unsafeInterleaveIO $ do
+          (files, dirs') <- collect [] [] =<< getDirectoryContents (topdir </> dir)
+          files' <- recurseDirectories (dirs' ++ dirs)
+          return (files ++ files')
+
+          where
+            collect files dirs' []              = return (reverse files
+                                                         ,reverse dirs')
+            collect files dirs' (entry:entries) | ignore entry
+                                                = collect files dirs' entries
+            collect files dirs' (entry:entries) = do
+              let dirEntry = dir </> entry
+              isDirectory <- doesDirectoryExist (topdir </> dirEntry)
+              if isDirectory
+                then collect files (dirEntry:dirs') entries
+                else collect (dirEntry:files) dirs' entries
+
+            ignore ['.']      = True
+            ignore ['.', '.'] = True
+            ignore _          = False
+
+-- https://github.com/haskell/directory/issues/110
+-- https://github.com/haskell/directory/issues/96
+-- https://www.sqlite.org/src/info/89f1848d7f
+rmPath :: (MonadIO m, MonadMask m)
+      => FilePath
+      -> m ()
+rmPath fp =
+#if defined(IS_WINDOWS)
+  recovering (fullJitterBackoff 25000 <> limitRetries 10)
+    [\_ -> Handler (\e -> pure $ isPermissionError e)
+    ,\_ -> Handler (\e -> pure (ioeGetErrorType e == UnsatisfiedConstraints))
+    ,\_ -> Handler (\e -> pure (ioeGetErrorType e == InappropriateType))
+    ]
+    (\_ -> liftIO $ removePathForcibly fp)
+#else
+  liftIO $ removeDirectoryRecursive fp
+#endif
+
+
+-- https://www.sqlite.org/src/info/89f1848d7f
+-- https://github.com/haskell/directory/issues/96
+rmFile :: (MonadIO m, MonadMask m)
+      => FilePath
+      -> m ()
+rmFile fp =
+#if defined(IS_WINDOWS)
+  recovering (fullJitterBackoff 25000 <> limitRetries 10)
+    [\_ -> Handler (\e -> pure $ isPermissionError e)
+    ,\_ -> Handler (\e -> pure (ioeGetErrorType e == UnsatisfiedConstraints))
+    ]
+    (\_ -> liftIO $ removeFile fp)
+#else
+  liftIO $ removeFile fp
+#endif
+
+
+-- Gathering monoidal values
+traverseFold :: (Foldable t, Applicative m, Monoid b) => (a -> m b) -> t a -> m b
+traverseFold f = foldl (\mb a -> (<>) <$> mb <*> f a) (pure mempty)
+
+-- | Gathering monoidal values
+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
+stripNewline :: String -> String
+stripNewline s
+  | null s               = []
+  | head s `elem` "\n\r" = stripNewline (tail s)
+  | otherwise            = head s : stripNewline (tail s)
+
+
+isNewLine :: Word8 -> Bool
+isNewLine w
+  | w == _lf = True
+  | w == _cr = True
+  | otherwise = False

lib/GHCup/Utils/String/QQ.hs

@@ -1,25 +1,35 @@
 {-# LANGUAGE TemplateHaskell #-}
 
--- | QuasiQuoter for non-interpolated strings, texts and bytestrings.
---
--- The "s" quoter contains a multi-line string with no interpolation at all,
--- except that the leading newline is trimmed and carriage returns stripped.
---
--- @
--- {-\# LANGUAGE QuasiQuotes #-}
--- import Data.Text (Text)
--- import Data.String.QQ
--- foo :: Text -- "String", "ByteString" etc also works
--- foo = [s|
--- Well here is a
---     multi-line string!
--- |]
--- @
---
--- Any instance of the IsString type is permitted.
---
--- (For GHC versions 6, write "[$s||]" instead of "[s||]".)
---
+{-|
+Module      : GHCup.Utils.String.QQ
+Description : String quasi quoters
+Copyright   : (c) Audrey Tang <audreyt@audreyt.org> 2019, Julian Ospald <hasufell@posteo.de> 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+
+QuasiQuoter for non-interpolated strings, texts and bytestrings.
+
+The "s" quoter contains a multi-line string with no interpolation at all,
+except that the leading newline is trimmed and carriage returns stripped.
+
+@
+{-\# LANGUAGE QuasiQuotes #-}
+import Data.Text (Text)
+import Data.String.QQ
+foo :: Text -- "String", "ByteString" etc also works
+foo = [s|
+Well here is a
+    multi-line string!
+|]
+@
+
+Any instance of the IsString type is permitted.
+
+(For GHC versions 6, write "[$s||]" instead of "[s||]".)
+
+-}
 module GHCup.Utils.String.QQ
   ( s
   )

lib/GHCup/Utils/Version/QQ.hs

@@ -7,6 +7,15 @@
 {-# LANGUAGE TemplateHaskell    #-}
 
 
+{-|
+Module      : GHCup.Utils.Version.QQ
+Description : Version quasi-quoters
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+-}
 module GHCup.Utils.Version.QQ where
 
 import           Data.Data
@@ -33,6 +42,8 @@ deriving instance Data SemVer
 deriving instance Lift SemVer
 deriving instance Data Mess
 deriving instance Lift Mess
+deriving instance Data MChunk
+deriving instance Lift MChunk
 deriving instance Data PVP
 deriving instance Lift PVP
 deriving instance Lift VSep
@@ -42,12 +53,11 @@ deriving instance Data VUnit
 
 #if !MIN_VERSION_base(4,13,0)
 deriving instance Lift (NonEmpty Word)
-instance Lift Text
 #endif
 
 qq :: (Text -> Q Exp) -> QuasiQuoter
 qq quoteExp' = QuasiQuoter
-  { quoteExp  = (\s -> quoteExp' . T.pack $ s)
+  { quoteExp  = \s -> quoteExp' . T.pack $ s
   , quotePat  = \_ ->
     fail "illegal QuasiQuote (allowed as expression only, used as a pattern)"
   , quoteType = \_ ->
@@ -91,4 +101,4 @@ liftText :: T.Text -> Q Exp
 liftText txt = AppE (VarE 'T.pack) <$> TH.lift (T.unpack txt)
 
 liftDataWithText :: Data a => a -> Q Exp
-liftDataWithText = dataToExpQ (\a -> liftText <$> cast a)
+liftDataWithText = dataToExpQ (fmap liftText . cast)

lib/GHCup/Version.hs

@@ -1,17 +1,49 @@
 {-# LANGUAGE QuasiQuotes       #-}
 
 
+{-|
+Module      : GHCup.Version
+Description : Version information and version handling.
+Copyright   : (c) Julian Ospald, 2020
+License     : LGPL-3.0
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : portable
+-}
 module GHCup.Version where
 
-import           GHCup.Utils.Version.QQ
+import           GHCup.Types
+import           Paths_ghcup (version)
 
-import           Data.Versions
+import           Data.Version (Version(versionBranch))
+import           Data.Versions hiding (version)
 import           URI.ByteString
 import           URI.ByteString.QQ
 
--- | This reflects the API version of the JSON.
-ghcupURL :: URI
-ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.1.json|]
+import qualified Data.List.NonEmpty            as NE
+import qualified Data.Text                     as T
 
+-- | This reflects the API version of the YAML.
+ghcupURL :: URI
+ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.5.yaml|]
+
+-- | The current ghcup version.
 ghcUpVer :: PVP
-ghcUpVer = [pver|0.1.0|]
+ghcUpVer = PVP . NE.fromList . fmap fromIntegral $ versionBranch version
+
+-- | ghcup version as numeric string.
+numericVer :: String
+numericVer = T.unpack . prettyPVP $ ghcUpVer
+
+versionCmp :: Versioning -> VersionCmp -> Bool
+versionCmp ver1 (VR_gt ver2)   = ver1 > ver2
+versionCmp ver1 (VR_gteq ver2) = ver1 >= ver2
+versionCmp ver1 (VR_lt ver2)   = ver1 < ver2
+versionCmp ver1 (VR_lteq ver2) = ver1 <= ver2
+versionCmp ver1 (VR_eq ver2)   = ver1 == ver2
+
+versionRange :: Versioning -> VersionRange -> Bool
+versionRange ver' (SimpleRange cmps) = and $ fmap (versionCmp ver') cmps
+versionRange ver' (OrRange cmps range) = 
+  versionRange ver' (SimpleRange cmps) || versionRange ver' range
+

shell-completions/bash

@@ -0,0 +1,14 @@
+_ghcup()
+{
+    local CMDLINE
+    local IFS=$'\n'
+    CMDLINE=(--bash-completion-index $COMP_CWORD)
+
+    for arg in ${COMP_WORDS[@]}; do
+        CMDLINE=(${CMDLINE[@]} --bash-completion-word $arg)
+    done
+
+    COMPREPLY=( $(ghcup "${CMDLINE[@]}") )
+}
+
+complete -o filenames -F _ghcup ghcup

shell-completions/fish

@@ -0,0 +1,19 @@
+ function _ghcup
+    set -l cl (commandline --tokenize --current-process)
+    # Hack around fish issue #3934
+    set -l cn (commandline --tokenize --cut-at-cursor --current-process)
+    set -l cn (count $cn)
+    set -l tmpline --bash-completion-enriched --bash-completion-index $cn
+    for arg in $cl
+      set tmpline $tmpline --bash-completion-word $arg
+    end
+    for opt in (ghcup $tmpline)
+      if test -d $opt
+        echo -E "$opt/"
+      else
+        echo -E "$opt"
+      end
+    end
+end
+
+complete --no-files --command ghcup --arguments '(_ghcup)'

shell-completions/zsh

@@ -0,0 +1,32 @@
+#compdef ghcup
+
+local request
+local completions
+local word
+local index=$((CURRENT - 1))
+
+request=(--bash-completion-enriched --bash-completion-index $index)
+for arg in ${words[@]}; do
+  request=(${request[@]} --bash-completion-word $arg)
+done
+
+IFS=$'\n' completions=($( ghcup "${request[@]}" ))
+
+for word in $completions; do
+  local -a parts
+
+  # Split the line at a tab if there is one.
+  IFS=$'\t' parts=($( echo $word ))
+
+  if [[ -n $parts[2] ]]; then
+     if [[ $word[1] == "-" ]]; then
+       local desc=("$parts[1] ($parts[2])")
+       compadd -d desc -- $parts[1]
+     else
+       local desc=($(print -f  "%-019s -- %s" $parts[1] $parts[2]))
+       compadd -l -d desc -- $parts[1]
+     fi
+  else
+    compadd -f -- $word
+  fi
+done

stack.yaml

@@ -0,0 +1,54 @@
+resolver: lts-17.11
+
+packages:
+  - .
+
+extra-deps:
+  - git: https://github.com/hasufell/text-conversions.git
+    commit: 9abf0e5e5664a3178367597c32db19880477a53c
+
+  - git: https://github.com/Bodigrim/tar
+    commit: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
+
+  - IfElse-0.85@sha256:6939b94acc6a55f545f63a168a349dd2fbe4b9a7cca73bf60282db5cc6aa47d2,445
+  - ascii-string-1.0.1.4@sha256:fa34f1d9ba57e8e89c0d4c9cef5e01ba32cb2d4373d13f92dcc0b531a6c6749b,2582
+  - 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-types-1.5.1@sha256:991c472f4e751e2f0d7aab6ad4220ef151d6160876dcf0511bbf876bbd432020,1298
+  - haskus-utils-variant-3.0@sha256:8d51e45d3b664e61ccc25a58b37c0ccc4ee7537138b9fee21cd15c356906dd34,2159
+  - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
+  - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
+  - hpath-posix-0.13.3@sha256:abe472cf16bccd3a8b8814865ed3551a728fde0f3a2baea2acc03023bec6c565,1615
+  - hspec-2.7.10@sha256:c9e82c90086acebac576552a06f3cabd249bba048edd1667c7fae0b1313d5bce,1712
+  - hspec-core-2.7.10@sha256:2aba6ea126442b29e8183ab27f1c811706b19b1d83b02f193a896f6fc1589d13,4621
+  - hspec-discover-2.7.10@sha256:d08bf5dd785629f589571477d9beb7cd91529471bd89f39517c1cb4b9b38160f,2184
+  - hspec-golden-aeson-0.9.0.0@sha256:aa17274114026661ba4dfc9c60c230673c8f408bd86482fd611d2d5cb6aff996,2179
+  - lzma-static-5.2.5.2@sha256:ac38dcad9ab423342a72ba48415bd75f62234e9c9e11831495b75603b5a060f6,7184
+  - libarchive-3.0.2.1@sha256:40ebf2a278e585802427bc58826867208bb33822f63d56107a1fcc3ca04d691d,10990
+  - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
+  - primitive-0.7.0.1@sha256:a381571c36edc7dca28b77fe8159b43c14c640087ec5946adacf949feec64231,3433
+  - regex-posix-clib-2.7
+  - streamly-0.7.3@sha256:ad2a488fe802692ed47cab9fd0416c2904aac9e51cf2d8aafd1c3a40064c42f5,27421
+  - streamly-bytestring-0.1.2@sha256:cc828f41d1c714c711d38fb213b4ed186febabba598ab080e13255f69c20b13c,2469
+  - 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
+
+flags:
+  http-io-streams:
+    brotli: false
+
+  libarchive:
+    system-libarchive: false
+
+  regex-posix:
+    _regex-posix-clib: true
+
+ghc-options:
+  "$locals": -O2
+  streamly: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+  ghcup: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16

test/GHCup/ArbitraryTypes.hs

@@ -0,0 +1,196 @@
+{-# OPTIONS_GHC -Wno-orphans #-}
+
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+module GHCup.ArbitraryTypes where
+
+
+import           GHCup.Types
+
+import           Data.ByteString                ( ByteString )
+import           Data.Versions
+import           Data.List.NonEmpty
+import           Test.QuickCheck
+import           Test.QuickCheck.Arbitrary.ADT  ( ToADTArbitrary )
+import           Test.QuickCheck.Arbitrary.Generic
+import           URI.ByteString
+
+import qualified Data.Map.Strict               as M
+import qualified Data.Text                     as T
+import qualified Data.Text.Encoding            as E
+import qualified Data.Text.Lazy                as T
+                                                ( toStrict )
+import qualified Data.Text.Lazy.Builder        as B
+import qualified Data.Text.Lazy.Builder.Int    as B
+
+
+    -----------------
+    --[ utilities ]--
+    -----------------
+
+intToText :: Integral a => a -> T.Text
+intToText = T.toStrict . B.toLazyText . B.decimal
+
+genVer :: Gen (Int, Int, Int)
+genVer =
+  (\x y z -> (getPositive x, getPositive y, getPositive z))
+    <$> arbitrary
+    <*> arbitrary
+    <*> arbitrary
+
+
+instance ToADTArbitrary GHCupInfo
+
+
+
+    ----------------------
+    --[ base arbitrary ]--
+    ----------------------
+
+instance Arbitrary T.Text where
+  arbitrary = fmap T.pack $ listOf $ elements ['a' .. 'z']
+  shrink xs = T.pack <$> shrink (T.unpack xs)
+
+instance Arbitrary (NonEmpty Word) where
+  arbitrary = fmap fromList $ listOf1 arbitrary
+
+-- utf8 encoded bytestring
+instance Arbitrary ByteString where
+  arbitrary = fmap (E.encodeUtf8 . T.pack) $ listOf $ elements ['a' .. 'z']
+
+
+
+    ---------------------
+    --[ uri arbitrary ]--
+    ---------------------
+
+instance Arbitrary Scheme where
+  arbitrary = oneof [ pure (Scheme "http"), pure (Scheme "https") ]
+
+instance Arbitrary Host where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary Port where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary (URIRef Absolute) where
+  arbitrary =
+    URI <$> arbitrary <*> pure Nothing <*> arbitrary <*> pure (Query []) <*> pure Nothing
+
+
+
+    -------------------------
+    --[ version arbitrary ]--
+    -------------------------
+
+instance Arbitrary Mess where
+  arbitrary = do
+    (x, y, z) <- genVer
+    pure
+      $ either (error . show) id
+      $ mess (intToText x <> "." <> intToText y <> "." <> intToText z)
+
+instance Arbitrary Version where
+  arbitrary = do
+    (x, y, z) <- genVer
+    pure
+      $ either (error . show) id
+      $ version (intToText x <> "." <> intToText y <> "." <> intToText z)
+
+instance Arbitrary SemVer where
+  arbitrary = do
+    (x, y, z) <- genVer
+    pure
+      $ either (error . show) id
+      $ semver (intToText x <> "." <> intToText y <> "." <> intToText z)
+
+instance Arbitrary PVP where
+  arbitrary = do
+    (x, y, z) <- genVer
+    pure
+      $ either (error . show) id
+      $ pvp (intToText x <> "." <> intToText y <> "." <> intToText z)
+
+instance Arbitrary Versioning where
+  arbitrary = Ideal <$> arbitrary
+
+
+
+    -----------------------
+    --[ ghcup arbitrary ]--
+    -----------------------
+
+instance Arbitrary Requirements where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary DownloadInfo where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary LinuxDistro where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary Platform where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary Tag where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary Architecture where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary VersionInfo where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary VersionRange where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary (NonEmpty VersionCmp) where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary VersionCmp where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary TarDir where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary Tool where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary GlobalTool where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary GHCupInfo where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+
+-- our maps are nested... the default size easily blows up most ppls ram
+
+instance {-# OVERLAPS #-} Arbitrary v => Arbitrary (M.Map Tool v) where
+  arbitrary = resize 8 $ M.fromList <$> arbitrary
+
+instance {-# OVERLAPS #-} Arbitrary v => Arbitrary (M.Map (Maybe Version) v) where
+  arbitrary = resize 8 $ M.fromList <$> arbitrary
+
+instance {-# OVERLAPS #-} Arbitrary v => Arbitrary (M.Map Platform v) where
+  arbitrary = resize 8 $ M.fromList <$> arbitrary
+
+instance {-# OVERLAPS #-} Arbitrary v => Arbitrary (M.Map (Maybe Versioning) v) where
+  arbitrary = resize 8 $ M.fromList <$> arbitrary
+

test/GHCup/Types/JSONSpec.hs

@@ -0,0 +1,16 @@
+{-# LANGUAGE TypeApplications #-}
+
+module GHCup.Types.JSONSpec where
+
+import           GHCup.ArbitraryTypes ()
+import           GHCup.Types
+import           GHCup.Types.JSON ()
+
+import           Test.Aeson.GenericSpecs
+import           Test.Hspec
+
+
+
+spec :: Spec
+spec = do
+  roundtripAndGoldenSpecs (Proxy @GHCupInfo)

test/Main.hs

@@ -0,0 +1,10 @@
+import Test.Hspec.Runner
+import Test.Hspec.Formatters
+import qualified Spec
+
+
+main :: IO ()
+main =
+  hspecWith
+    defaultConfig { configFormatter = Just progress }
+    Spec.spec

test/MyLibTest.hs

@@ -1,4 +0,0 @@
-module Main (main) where
-
-main :: IO ()
-main = putStrLn "Test suite not yet implemented."

test/Spec.hs

@@ -0,0 +1,2 @@
+-- file test/Spec.hs
+{-# OPTIONS_GHC -F -pgmF hspec-discover -optF --module-name=Spec #-}

update-index-state.sh

@@ -1,66 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu
-
-status_message() {
-    printf "\\033[0;32m%s\\033[0m\\n" "$1"
-}
-
-error_message() {
-    printf "\\033[0;31m%s\\033[0m\\n" "$1"
-}
-
-SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
-CACHE_LOCATION="${HOME}/.cabal/packages/hackage.haskell.org/01-index.cache"
-
-if [ ! -f "${CACHE_LOCATION}" ] ; then
-	error_message "${CACHE_LOCATION} does not exist, did you run 'cabal update'?"
-	exit 1
-fi
-
-if [ ! -f "${SCRIPTPATH}/cabal.project" ] ; then
-	error_message "Could not find ${SCRIPTPATH}/cabal.project, skipping index state update."
-	exit 3
-fi
-
-cabal v2-update
-
-arch=$(getconf LONG_BIT)
-
-case "${arch}" in
-32)
-	byte_size=4
-	magic_word="CABA1002"
-    ;;
-64)
-	byte_size=8
-	magic_word="00000000CABA1002"
-    ;;
-*)
-	error_message "Unknown architecture (long bit): ${arch}"
-	exit 2
-    ;;
-esac
-
-# This is the logic to parse the binary format of 01-index.cache.
-# The first word is a magic 'caba1002', the second one is the timestamp in unix epoch.
-# Better than copying the cabal-install source code.
-if [ "$(xxd -u -p -l${byte_size} -s 0 "${CACHE_LOCATION}")" != "${magic_word}" ] ; then
-	error_message "Magic word does not match!"
-	exit 4
-fi
-cache_timestamp=$(echo "ibase=16;obase=A;$(xxd -u -p -l${byte_size} -s ${byte_size} "${CACHE_LOCATION}")" | bc)
-
-# If we got junk from the binary file, this should fail.
-cache_date=$(date --utc --date "@${cache_timestamp}" "+%FT%TZ")
-
-
-status_message "Updating index state in ${SCRIPTPATH}/cabal.project"
-
-if grep -q "^index-state: .*" "${SCRIPTPATH}/cabal.project" ; then
-	awk '/index-state:/ {gsub(/.*/, "index-state: '${cache_date}'")}; { print }' "${SCRIPTPATH}/cabal.project" > "${SCRIPTPATH}/cabal.project.tmp"
-	mv "${SCRIPTPATH}/cabal.project.tmp" "${SCRIPTPATH}/cabal.project"
-else
-	printf "index-state: %s\n" "${cache_date}" >> "${SCRIPTPATH}/cabal.project"
-fi
-

www/LICENSE

@@ -0,0 +1,208 @@
+The ghcup website, excluding ghcup, fonts, bootstrap-haskell script are subject
+to the license below. Design, javascript and css are used from the rustup
+project: https://github.com/rust-lang/rustup.rs/tree/master/www
+
+
+
+===============================================================================
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

www/copy.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" focusable="false" width="1.66em" height="2em" style="-ms-transform: rotate(360deg); -webkit-transform: rotate(360deg); transform: rotate(360deg);" preserveAspectRatio="xMidYMid meet" viewBox="0 0 14 16"><path fill-rule="evenodd" d="M2 13h4v1H2v-1zm5-6H2v1h5V7zm2 3V8l-3 3l3 3v-2h5v-2H9zM4.5 9H2v1h2.5V9zM2 12h2.5v-1H2v1zm9 1h1v2c-.02.28-.11.52-.3.7c-.19.18-.42.28-.7.3H1c-.55 0-1-.45-1-1V4c0-.55.45-1 1-1h3c0-1.11.89-2 2-2c1.11 0 2 .89 2 2h3c.55 0 1 .45 1 1v5h-1V6H1v9h10v-2zM2 5h8c0-.55-.45-1-1-1H8c-.55 0-1-.45-1-1s-.45-1-1-1s-1 .45-1 1s-.45 1-1 1H3c-.55 0-1 .45-1 1z" fill="#626262"/></svg>

www/fonts/OFL.txt

@@ -0,0 +1,92 @@
+Copyright (c) 2011, Raph Levien (firstname.lastname@gmail.com), Copyright (c) 2012, Cyreal (cyreal.org)
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

www/ghcup.css

@@ -0,0 +1,242 @@
+@font-face {
+    font-family: 'Fira Sans';
+    font-style: normal;
+    font-weight: 300;
+    src: local('Fira Sans Light'), url("fonts/FiraSans-Light.woff") format('woff');
+}
+@font-face {
+    font-family: 'Fira Sans';
+    font-style: normal;
+    font-weight: 400;
+    src: local('Fira Sans'), url("fonts/FiraSans-Regular.woff") format('woff');
+}
+@font-face {
+    font-family: 'Fira Sans';
+    font-style: normal;
+    font-weight: 500;
+    src: local('Fira Sans Medium'), url("fonts/FiraSans-Medium.woff") format('woff');
+}
+
+@font-face {
+    font-family: 'Work Sans';
+    font-style: normal;
+    font-weight: 500;
+    src: local('Work Sans Medium'), url("fonts/WorkSans-Medium.ttf") format('ttf');
+}
+
+@font-face {
+    font-family: 'Inconsolata';
+    font-style: normal;
+    font-weight: 400;
+    src: local('Inconsolata Regular'), url("fonts/Inconsolata-Regular.ttf") format('ttf');
+}
+
+body {
+    margin-top: 2em;
+    background-color: white;
+    color: #515151;
+    font-family: "Fira Sans","Helvetica Neue",Helvetica,Arial,sans-serif;
+    font-weight: 300;
+    font-size: 25px;
+}
+
+pre {
+    font-family: Inconsolata,Menlo,Monaco,Consolas,"Courier New",monospace;
+    font-weight: 400;
+}
+
+body#idx #pitch > a {
+    font-weight: 500;
+    line-height: 2em;
+}
+
+a {
+    color: #428bca;
+    text-decoration: none;
+}
+
+a:hover {
+    color: rgb(42, 100, 150);
+}
+
+body#idx > * {
+    margin-left: auto;
+    margin-right: auto;
+    text-align: center;
+    width: 37em;
+}
+
+body#idx > #pitch {
+    width: 30rem;
+}
+
+#pitch em {
+    font-style: normal;
+    font-weight: 400;
+}
+
+body#idx p {
+    margin-top: 2em;
+    margin-bottom: 2em;
+}
+
+body#idx p.other-help {
+    font-size: 0.6em;
+}
+
+.instructions {
+    background-color: rgb(250, 250, 250);
+    margin-left: auto;
+    margin-right: auto;
+    border-radius: 3px;
+    border: 1px solid rgb(204, 204, 204);
+    box-shadow: 0px 1px 4px 0px rgb(204, 204, 204);
+}
+
+.instructions > * {
+    width: 55rem;
+    margin-left: auto;
+    margin-right: auto;
+}
+
+.instructions div.command-button {
+	display: flex;
+	align-items: center;
+}
+
+.instructions div.command-button button {
+	color: white;
+	/* border: none; */
+	background-color: rgb(242, 242, 242);
+	border-width: 2px;
+	border-style: solid;
+	border-radius: 3px;
+
+    margin-left: 0.5rem;
+    margin-right: auto;
+	margin-top: 25px;
+	margin-bottom: 25px;
+    text-align: center;
+}
+
+.instructions div.command-button button:hover {
+	background: rgb(232, 232, 232);
+}
+
+.instructions div.command-button button:focus {
+	background: rgb(222, 222, 222);
+}
+
+hr {
+    margin-top: 2em;
+    margin-bottom: 2em;
+}
+
+#platform-instructions-linux > div > pre,
+#platform-instructions-mac > div > pre,
+#platform-instructions-freebsd > div > pre,
+#platform-instructions-win32 > div > pre,
+#platform-instructions-win64 > div > pre,
+#platform-instructions-default > div > div > pre,
+#platform-instructions-unknown > div > div > pre {
+    background-color: #515151;
+    color: white;
+    margin-left: auto;
+    padding-top: 1rem;
+    padding-bottom: 1rem;
+    padding-right: 1rem;
+    text-align: center;
+    border-radius: 3px;
+    box-shadow: inset 0px 0px 20px 0px #333333;
+	font-size: 0.6em;
+	width: 40rem;
+}
+
+#platform-instructions-win32 a.windows-download,
+#platform-instructions-win64 a.windows-download,
+#platform-instructions-default a.windows-download,
+#platform-instructions-unknown a.windows-download {
+    display: block;
+    padding-top: 0.4rem;
+    padding-bottom: 0.6rem;
+    font-family: "Work Sans", "Fira Sans","Helvetica Neue",Helvetica,Arial,sans-serif;
+    font-weight: 500;
+    letter-spacing: 0.1rem;
+}
+
+/* This is the box that prints navigator.platform, navigator.appVersion values */
+#platform-instructions-unknown > div:first-of-type {
+    font-size: 16px;
+    line-height: 2rem;
+}
+
+#about {
+    font-size: 16px;
+    line-height: 2em;
+}
+
+#about > img {
+    width: 30px;
+    height: 30px;
+    transform: translateY(11px);
+}
+
+#platform-button {
+    background-color: #515151;
+    color: white;
+    margin-left: auto;
+    margin-right: auto;
+    padding: 1em;
+}
+
+.ghcup-command:before {
+    color: #999;
+    content: " $ ";
+}
+
+ /* Tooltip container */
+.tooltip {
+  position: relative;
+  display: inline-block;
+  /* border-bottom: 1px dotted black; [> If you want dots under the hoverable text <] */
+}
+
+/* Tooltip text */
+.tooltip .tooltiptext {
+  visibility: hidden;
+  width: 120px;
+  background-color: #555;
+  color: #fff;
+  text-align: center;
+  padding: 5px 0;
+  border-radius: 6px;
+
+  /* Position the tooltip text */
+  position: absolute;
+  z-index: 1;
+  bottom: 125%;
+  left: 50%;
+  margin-left: -60px;
+
+  /* Fade in tooltip */
+  opacity: 0;
+  transition: opacity 0.3s;
+}
+
+/* Tooltip arrow */
+.tooltip .tooltiptext::after {
+  content: "";
+  position: absolute;
+  top: 100%;
+  left: 50%;
+  margin-left: -5px;
+  border-width: 5px;
+  border-style: solid;
+  border-color: #555 transparent transparent transparent;
+}
+
+/* Show the tooltip text when you mouse over the tooltip container */
+.tooltip:hover .tooltiptext {
+  visibility: visible;
+  opacity: 1;
+}

www/ghcup.js

@@ -0,0 +1,176 @@
+var platforms = ["default", "unknown", "win32", "win64", "linux", "freebsd", "mac"];
+var platform_override = null;
+
+function detect_platform() {
+    "use strict";
+
+    if (platform_override !== null) {
+        return platforms[platform_override];
+    }
+
+    var os = "unknown";
+
+    if (navigator.platform == "Linux x86_64") {os = "linux";}
+    if (navigator.platform == "Linux i686") {os = "linux";}
+    if (navigator.platform == "Linux i686 on x86_64") {os = "linux";}
+    if (navigator.platform == "Linux aarch64") {os = "linux";}
+    if (navigator.platform == "Linux armv6l") {os = "linux";}
+    if (navigator.platform == "Linux armv7l") {os = "linux";}
+    if (navigator.platform == "Linux armv8l") {os = "linux";}
+    if (navigator.platform == "Linux ppc64") {os = "linux";}
+    if (navigator.platform == "Linux mips") {os = "linux";}
+    if (navigator.platform == "Linux mips64") {os = "linux";}
+    if (navigator.platform == "Mac") {os = "mac";}
+    if (navigator.platform == "Win32") {os = "win32";}
+    if (navigator.platform == "Win64" ||
+        navigator.userAgent.indexOf("WOW64") != -1 ||
+        navigator.userAgent.indexOf("Win64") != -1) { os = "win64"; }
+    if (navigator.platform == "FreeBSD x86_64") {os = "freebsd";}
+    if (navigator.platform == "FreeBSD amd64") {os = "freebsd";}
+    // if (navigator.platform == "NetBSD x86_64") {os = "unix";}
+    // if (navigator.platform == "NetBSD amd64") {os = "unix";}
+
+    // I wish I knew by now, but I don't. Try harder.
+    if (os == "unknown") {
+        if (navigator.appVersion.indexOf("Win")!=-1) {os = "win32";}
+        if (navigator.appVersion.indexOf("Mac")!=-1) {os = "mac";}
+        if (navigator.appVersion.indexOf("FreeBSD")!=-1) {os = "freebsd";}
+    }
+
+    // Firefox Quantum likes to hide platform and appVersion but oscpu works
+    if (navigator.oscpu) {
+        if (navigator.oscpu.indexOf("Win32")!=-1) {os = "win32";}
+        if (navigator.oscpu.indexOf("Win64")!=-1) {os = "win64";}
+        if (navigator.oscpu.indexOf("Mac")!=-1) {os = "mac";}
+        if (navigator.oscpu.indexOf("Linux")!=-1) {os = "linux";}
+        if (navigator.oscpu.indexOf("FreeBSD")!=-1) {os = "freebsd";}
+        // if (navigator.oscpu.indexOf("NetBSD")!=-1) {os = "unix";}
+    }
+
+    return os;
+}
+
+function adjust_for_platform() {
+    "use strict";
+
+    var platform = detect_platform();
+
+    platforms.forEach(function (platform_elem) {
+        var platform_div = document.getElementById("platform-instructions-" + platform_elem);
+        platform_div.style.display = "none";
+        if (platform == platform_elem) {
+            platform_div.style.display = "block";
+        }
+    });
+
+    adjust_platform_specific_instrs(platform);
+}
+
+function adjust_platform_specific_instrs(platform) {
+    var platform_specific = document.getElementsByClassName("platform-specific");
+    for (var el of platform_specific) {
+        var el_is_not_win = el.className.indexOf("not-win") !== -1;
+        var el_is_inline = el.tagName.toLowerCase() == "span";
+        var el_visible_style = "block";
+        if (el_is_inline) {
+            el_visible_style = "inline";
+        }
+        if (platform == "win64" || platform == "win32") {
+            if (el_is_not_win) {
+                el.style.display = "none";
+            } else {
+                el.style.display = el_visible_style;
+            }
+        } else {
+            if (el_is_not_win) {
+                el.style.display = el_visible_style;
+            } else {
+                el.style.display = "none";
+            }
+        }
+    }
+}
+
+function cycle_platform() {
+    if (platform_override == null) {
+        platform_override = 0;
+    } else {
+        platform_override = (platform_override + 1) % platforms.length;
+    }
+    adjust_for_platform();
+}
+
+function set_up_cycle_button() {
+    var cycle_button = document.getElementById("platform-button");
+    cycle_button.onclick = cycle_platform;
+
+    var key="test";
+    var idx=0;
+    var unlocked=false;
+
+    document.onkeypress = function(event) {
+        if (event.key == "n" && unlocked) {
+            cycle_platform();
+        }
+
+        if (event.key == key[idx]) {
+            idx += 1;
+
+            if (idx == key.length) {
+                cycle_button.style.display = "block";
+                unlocked = true;
+                cycle_platform();
+            }
+        } else if (event.key == key[0]) {
+            idx = 1;
+        } else {
+            idx = 0;
+        }
+    };
+}
+
+function go_to_default_platform() {
+    platform_override = 0;
+    adjust_for_platform();
+}
+
+function set_up_default_platform_buttons() {
+    var defaults_buttons = document.getElementsByClassName('default-platform-button');
+    for (var i = 0; i < defaults_buttons.length; i++) {
+        defaults_buttons[i].onclick = go_to_default_platform;
+    }
+}
+
+function fill_in_bug_report_values() {
+    var nav_plat = document.getElementById("nav-plat");
+    var nav_app = document.getElementById("nav-app");
+    nav_plat.textContent = navigator.platform;
+    nav_app.textContent = navigator.appVersion;
+}
+
+function copyToClipboard() {
+  const text = document.getElementById("ghcup-command-normal").innerText;
+  const el = document.createElement('textarea');
+  el.value = text;
+  document.body.appendChild(el);
+  el.select();
+  document.execCommand('copy');
+  document.body.removeChild(el);
+}
+
+function copyToClipboardSilicon() {
+  const text = document.getElementById("ghcup-command-silicon").innerText;
+  const el = document.createElement('textarea');
+  el.value = text;
+  document.body.appendChild(el);
+  el.select();
+  document.execCommand('copy');
+  document.body.removeChild(el);
+}
+
+(function () {
+    adjust_for_platform();
+    set_up_cycle_button();
+    set_up_default_platform_buttons();
+    fill_in_bug_report_values();
+}());

www/haskell-logo.svg

@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="109"
+   height="80"
+   viewBox="0 0 109.00001 80"
+   version="1.1"
+   id="svg14"
+   sodipodi:docname="haskell-logo.svg"
+   inkscape:version="0.92.3 (2405546, 2018-03-11)">
+  <metadata
+     id="metadata20">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs18" />
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1916"
+     inkscape:window-height="1033"
+     id="namedview16"
+     showgrid="false"
+     inkscape:zoom="2.0159478"
+     inkscape:cx="298.15447"
+     inkscape:cy="-2.7202801"
+     inkscape:window-x="1366"
+     inkscape:window-y="22"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="svg14" />
+  <path
+     d="M 1.842,77.722 26.586,40.63 1.842,3.537 H 20.4 L 45.144,40.63 20.4,77.722 Z m 0,0"
+     id="path8"
+     inkscape:connector-curvature="0"
+     style="fill:#453a62" />
+  <path
+     d="M 26.586,77.722 51.33,40.63 26.586,3.537 H 45.144 L 94.63,77.722 H 76.074 L 60.61,54.54 45.143,77.722 Z m 0,0"
+     id="path10"
+     inkscape:connector-curvature="0"
+     style="fill:#5e5086" />
+  <path
+     d="M 86.384,56.085 78.136,43.72 h 28.868 V 56.086 H 86.384 Z M 74.012,37.54 65.764,25.175 h 41.24 V 37.54 Z m 0,0"
+     id="path12"
+     inkscape:connector-curvature="0"
+     style="fill:#8f4e8b" />
+</svg>

www/index.html

@@ -0,0 +1,190 @@
+<!DOCTYPE html>
+
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>ghcup - The Haskell (GHC) toolchain installer</title>
+    <meta name="keywords" content="Haskell, Haskell programming language, ghc, ghcup">
+    <meta name="description" content="The Haskell (GHC) toolchain installer">
+
+    <link rel="stylesheet" href="normalize.css">
+    <link rel="stylesheet" href="ghcup.css">
+
+  </head>
+
+  <body id="idx">
+
+    <script id='html-content' type="text/html">
+      <a id="platform-button" style="display: none;" href="#">
+        click or press "n" to cycle platforms
+      </a>
+
+      <p id="pitch">
+        <em>ghcup</em> is the main installer for<br/>
+        the general purpose language <a href="https://www.haskell.org/">Haskell</a>
+      </p>
+
+      <div id="platform-instructions-linux" class="instructions" style="display: none;">
+        <p>Run the following in your terminal (as a user other than root), then follow the onscreen instructions.</p>
+		<div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+        <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.<br/>You appear to be running Linux. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
+      </div>
+
+      <div id="platform-instructions-mac" class="instructions" style="display: none;">
+        <p>Run the following in your terminal (as a user other than root), then follow the onscreen instructions.</p>
+		<p>On Intel:</p>
+		<div class="command-button"><pre><span class='ghcup-command' id="ghcup-command-normal">curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+        <p>On Apple Silicon:</p>
+		<div class="command-button"><pre><span class='ghcup-command' id="ghcup-command-silicon">curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | arch -x86_64 /bin/bash</span></pre><button class="tooltip" onclick="copyToClipboardSilicon()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+        <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.<br/>You appear to be running macOS. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
+      </div>
+
+      <div id="platform-instructions-freebsd" class="instructions" style="display: none;">
+        <p>Run the following in your terminal (as a user other than root), then follow the onscreen instructions.</p>
+		<div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+        <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.<br/>You appear to be running FreeBSD. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
+      </div>
+
+      <div id="platform-instructions-win32" class="instructions">
+        <p>
+          To install Haskell, follow the instructions on
+          <a class="windows-download" href="https://www.haskell.org/platform/#windows">Haskell Platform</a>
+		<p>If you're a Windows Subsystem 2 for Linux user run the following in your terminal, then follow the onscreen instructions to install Haskell.
+		</p>
+		<div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+        </p>
+		<p class="other-help">WSL1 does not work with ghcup, follow  <a href="https://docs.microsoft.com/en-us/windows/wsl/install-win10">the instructions here</a> to upgrade to WSL2 if needed.</br>You appear to be running Windows 32-bit. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
+      </div>
+
+      <div id="platform-instructions-win64" class="instructions" style="display: none;">
+        <p>
+          To install Haskell, follow the instructions on
+          <a class="windows-download" href="https://www.haskell.org/platform/#windows">Haskell Platform</a>
+        </p>
+		<p>If you're a Windows Subsystem 2 for Linux user run the following in your terminal, then follow the onscreen instructions to install Haskell.
+		</p>
+		<div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+		<p class="other-help">WSL1 does not work with ghcup, follow  <a href="https://docs.microsoft.com/en-us/windows/wsl/install-win10">the instructions here</a> to upgrade to WSL2 if needed.</br>You appear to be running Windows 64-bit. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
+      </div>
+
+      <div id="platform-instructions-unknown" class="instructions" style="display: none;">
+        <!-- unrecognized platform: ask for help -->
+        <p>I don't recognize your platform.</p>
+        <p>
+          ghcup runs on Linux, macOS and FreeBSD. If
+          you are on one of these platforms and are seeing this then please
+          <a href="https://gitlab.haskell.org/haskell/ghcup-hs/issues">report an issue</a>,
+          along with the following values:
+        </p>
+
+        <div>
+          <div>navigator.platform:</div>
+          <div id="nav-plat"></div>
+          <div>navigator.appVersion:</div>
+          <div id="nav-app"></div>
+        </div>
+
+        <!-- duplicate the default cross-platform instructions -->
+        <div>
+          <p>If you are running Linux, macOS, FreeBSD or Windows Subsystem 2 for Linux, run the following in your terminal (as a user other than root), then follow the onscreen instructions.</p>
+		  <div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+          <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.</p>
+        </div>
+
+        <hr/>
+
+        <div>
+          <p>
+            If you are running Windows,<br/>follow the instructions on
+            <a class="windows-download" href="https://www.haskell.org/platform/#windows">Haskell Platform</a>
+          </p>
+        </div>
+
+      </div>
+
+      <div id="platform-instructions-default" class="instructions">
+        <div>
+          <p>To install Haskell, if you are running Linux, macOS (on Intel), FreeBSD or Windows Subsystem 2 for Linux, run the following
+          in your terminal (as a user other than root), then follow the onscreen instructions.</p>
+		  <div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+          <p>For macOS on Apple Silicon, run this instead:</p>
+          <div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | arch -x86_64 /bin/bash</span></pre><button class="tooltip" onclick="copyToClipboardSilicon()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+          <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.</p>
+        </div>
+
+        <hr/>
+
+        <div>
+          <p>
+            If you are running Windows,<br/>follow the instructions on
+            <a class="windows-download" href="https://www.haskell.org/platform/#windows">Haskell Platform</a>
+          </p>
+        </div>
+
+      </div>
+
+      <p>
+        Need help? Ask on <a href="https://kiwiirc.com/nextclient/irc.libera.chat/#haskell-ghcup">#haskell-ghcup</a>, <a href="https://kiwiirc.com/nextclient/irc.libera.chat/#haskell">#haskell</a> or <a href="https://gitlab.haskell.org/haskell/ghcup-hs/issues">report a bug</a>.
+      </p>
+
+      <p id="about">
+        <img src="haskell-logo.svg" alt="" />
+        ghcup is a haskell.org hosted project.
+        <br/>
+        <a href="https://www.haskell.org/downloads/">other installation options</a>
+        &nbsp;&middot;&nbsp;
+        <a href="https://gitlab.haskell.org/haskell/ghcup-hs">about ghcup</a>
+        &nbsp;&middot;&nbsp;
+        <a href="https://github.com/rust-lang/rustup.rs/tree/master/www">web design from rustup</a>
+      </p>
+    </script>
+    <script>
+      document.write(document.getElementById("html-content").innerHTML);
+    </script>
+    <script type="text/javascript" src="ghcup.js"></script>
+
+    <noscript>
+      <p id="pitch">
+        <em>ghcup</em> is the main installer for<br/>
+        the general purpose language <a href="https://www.haskell.org/">Haskell</a>
+      </p>
+
+      <div id="platform-instructions-default" class="instructions">
+        <div>
+          <p>To install Haskell, if you are running Linux, macOS (on Intel), FreeBSD or Windows Subsystem for Linux 2, run the following
+          in your terminal (as a user other than root), then follow the onscreen instructions.</p>
+		  <pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre>
+          <p>For macOS on Apple Silicon, run this instead:</p>
+          <div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | arch -x86_64 /bin/bash</span></pre><button class="tooltip" onclick="copyToClipboardSilicon()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+          <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.</p>
+        </div>
+
+        <hr/>
+
+        <div>
+          <p>
+            If you are running Windows,<br/>follow the instructions on
+            <a class="windows-download" href="https://www.haskell.org/platform/#windows">Haskell Platform</a>
+          </p>
+        </div>
+
+      </div>
+
+      <p>
+        Need help? Ask on <a href="https://kiwiirc.com/nextclient/irc.libera.chat/#haskell-ghcup">#haskell-ghcup</a>, <a href="https://kiwiirc.com/nextclient/irc.libera.chat/#haskell">#haskell</a> or <a href="https://gitlab.haskell.org/haskell/ghcup-hs/issues">report a bug</a>.
+      </p>
+
+      <p id="about">
+        <img src="haskell-logo.svg" alt="" />
+        ghcup is a haskell.org hosted project.
+        <br/>
+        <a href="https://www.haskell.org/downloads/">other installation options</a>
+        &nbsp;&middot;&nbsp;
+        <a href="https://gitlab.haskell.org/haskell/ghcup-hs">about ghcup</a>
+        &nbsp;&middot;&nbsp;
+        <a href="https://github.com/rust-lang/rustup.rs/tree/master/www">web design from rustup</a>
+      </p>
+
+    </noscript>
+  </body>
+</html>

www/normalize.css

@@ -0,0 +1,427 @@
+/*! normalize.css v3.0.2 | MIT License | git.io/normalize */
+
+/**
+ * 1. Set default font family to sans-serif.
+ * 2. Prevent iOS text size adjust after orientation change, without disabling
+ *    user zoom.
+ */
+
+html {
+  font-family: sans-serif; /* 1 */
+  -ms-text-size-adjust: 100%; /* 2 */
+  -webkit-text-size-adjust: 100%; /* 2 */
+}
+
+/**
+ * Remove default margin.
+ */
+
+body {
+  margin: 0;
+}
+
+/* HTML5 display definitions
+   ========================================================================== */
+
+/**
+ * Correct `block` display not defined for any HTML5 element in IE 8/9.
+ * Correct `block` display not defined for `details` or `summary` in IE 10/11
+ * and Firefox.
+ * Correct `block` display not defined for `main` in IE 11.
+ */
+
+article,
+aside,
+details,
+figcaption,
+figure,
+footer,
+header,
+hgroup,
+main,
+menu,
+nav,
+section,
+summary {
+  display: block;
+}
+
+/**
+ * 1. Correct `inline-block` display not defined in IE 8/9.
+ * 2. Normalize vertical alignment of `progress` in Chrome, Firefox, and Opera.
+ */
+
+audio,
+canvas,
+progress,
+video {
+  display: inline-block; /* 1 */
+  vertical-align: baseline; /* 2 */
+}
+
+/**
+ * Prevent modern browsers from displaying `audio` without controls.
+ * Remove excess height in iOS 5 devices.
+ */
+
+audio:not([controls]) {
+  display: none;
+  height: 0;
+}
+
+/**
+ * Address `[hidden]` styling not present in IE 8/9/10.
+ * Hide the `template` element in IE 8/9/11, Safari, and Firefox < 22.
+ */
+
+[hidden],
+template {
+  display: none;
+}
+
+/* Links
+   ========================================================================== */
+
+/**
+ * Remove the gray background color from active links in IE 10.
+ */
+
+a {
+  background-color: transparent;
+}
+
+/**
+ * Improve readability when focused and also mouse hovered in all browsers.
+ */
+
+a:active,
+a:hover {
+  outline: 0;
+}
+
+/* Text-level semantics
+   ========================================================================== */
+
+/**
+ * Address styling not present in IE 8/9/10/11, Safari, and Chrome.
+ */
+
+abbr[title] {
+  border-bottom: 1px dotted;
+}
+
+/**
+ * Address style set to `bolder` in Firefox 4+, Safari, and Chrome.
+ */
+
+b,
+strong {
+  font-weight: bold;
+}
+
+/**
+ * Address styling not present in Safari and Chrome.
+ */
+
+dfn {
+  font-style: italic;
+}
+
+/**
+ * Address variable `h1` font-size and margin within `section` and `article`
+ * contexts in Firefox 4+, Safari, and Chrome.
+ */
+
+h1 {
+  font-size: 2em;
+  margin: 0.67em 0;
+}
+
+/**
+ * Address styling not present in IE 8/9.
+ */
+
+mark {
+  background: #ff0;
+  color: #000;
+}
+
+/**
+ * Address inconsistent and variable font size in all browsers.
+ */
+
+small {
+  font-size: 80%;
+}
+
+/**
+ * Prevent `sub` and `sup` affecting `line-height` in all browsers.
+ */
+
+sub,
+sup {
+  font-size: 75%;
+  line-height: 0;
+  position: relative;
+  vertical-align: baseline;
+}
+
+sup {
+  top: -0.5em;
+}
+
+sub {
+  bottom: -0.25em;
+}
+
+/* Embedded content
+   ========================================================================== */
+
+/**
+ * Remove border when inside `a` element in IE 8/9/10.
+ */
+
+img {
+  border: 0;
+}
+
+/**
+ * Correct overflow not hidden in IE 9/10/11.
+ */
+
+svg:not(:root) {
+  overflow: hidden;
+}
+
+/* Grouping content
+   ========================================================================== */
+
+/**
+ * Address margin not present in IE 8/9 and Safari.
+ */
+
+figure {
+  margin: 1em 40px;
+}
+
+/**
+ * Address differences between Firefox and other browsers.
+ */
+
+hr {
+  -moz-box-sizing: content-box;
+  box-sizing: content-box;
+  height: 0;
+}
+
+/**
+ * Contain overflow in all browsers.
+ */
+
+pre {
+  overflow: auto;
+}
+
+/**
+ * Address odd `em`-unit font size rendering in all browsers.
+ */
+
+code,
+kbd,
+pre,
+samp {
+  font-family: monospace, monospace;
+  font-size: 1em;
+}
+
+/* Forms
+   ========================================================================== */
+
+/**
+ * Known limitation: by default, Chrome and Safari on OS X allow very limited
+ * styling of `select`, unless a `border` property is set.
+ */
+
+/**
+ * 1. Correct color not being inherited.
+ *    Known issue: affects color of disabled elements.
+ * 2. Correct font properties not being inherited.
+ * 3. Address margins set differently in Firefox 4+, Safari, and Chrome.
+ */
+
+button,
+input,
+optgroup,
+select,
+textarea {
+  color: inherit; /* 1 */
+  font: inherit; /* 2 */
+  margin: 0; /* 3 */
+}
+
+/**
+ * Address `overflow` set to `hidden` in IE 8/9/10/11.
+ */
+
+button {
+  overflow: visible;
+}
+
+/**
+ * Address inconsistent `text-transform` inheritance for `button` and `select`.
+ * All other form control elements do not inherit `text-transform` values.
+ * Correct `button` style inheritance in Firefox, IE 8/9/10/11, and Opera.
+ * Correct `select` style inheritance in Firefox.
+ */
+
+button,
+select {
+  text-transform: none;
+}
+
+/**
+ * 1. Avoid the WebKit bug in Android 4.0.* where (2) destroys native `audio`
+ *    and `video` controls.
+ * 2. Correct inability to style clickable `input` types in iOS.
+ * 3. Improve usability and consistency of cursor style between image-type
+ *    `input` and others.
+ */
+
+button,
+html input[type="button"], /* 1 */
+input[type="reset"],
+input[type="submit"] {
+  -webkit-appearance: button; /* 2 */
+  cursor: pointer; /* 3 */
+}
+
+/**
+ * Re-set default cursor for disabled elements.
+ */
+
+button[disabled],
+html input[disabled] {
+  cursor: default;
+}
+
+/**
+ * Remove inner padding and border in Firefox 4+.
+ */
+
+button::-moz-focus-inner,
+input::-moz-focus-inner {
+  border: 0;
+  padding: 0;
+}
+
+/**
+ * Address Firefox 4+ setting `line-height` on `input` using `!important` in
+ * the UA stylesheet.
+ */
+
+input {
+  line-height: normal;
+}
+
+/**
+ * It's recommended that you don't attempt to style these elements.
+ * Firefox's implementation doesn't respect box-sizing, padding, or width.
+ *
+ * 1. Address box sizing set to `content-box` in IE 8/9/10.
+ * 2. Remove excess padding in IE 8/9/10.
+ */
+
+input[type="checkbox"],
+input[type="radio"] {
+  box-sizing: border-box; /* 1 */
+  padding: 0; /* 2 */
+}
+
+/**
+ * Fix the cursor style for Chrome's increment/decrement buttons. For certain
+ * `font-size` values of the `input`, it causes the cursor style of the
+ * decrement button to change from `default` to `text`.
+ */
+
+input[type="number"]::-webkit-inner-spin-button,
+input[type="number"]::-webkit-outer-spin-button {
+  height: auto;
+}
+
+/**
+ * 1. Address `appearance` set to `searchfield` in Safari and Chrome.
+ * 2. Address `box-sizing` set to `border-box` in Safari and Chrome
+ *    (include `-moz` to future-proof).
+ */
+
+input[type="search"] {
+  -webkit-appearance: textfield; /* 1 */
+  -moz-box-sizing: content-box;
+  -webkit-box-sizing: content-box; /* 2 */
+  box-sizing: content-box;
+}
+
+/**
+ * Remove inner padding and search cancel button in Safari and Chrome on OS X.
+ * Safari (but not Chrome) clips the cancel button when the search input has
+ * padding (and `textfield` appearance).
+ */
+
+input[type="search"]::-webkit-search-cancel-button,
+input[type="search"]::-webkit-search-decoration {
+  -webkit-appearance: none;
+}
+
+/**
+ * Define consistent border, margin, and padding.
+ */
+
+fieldset {
+  border: 1px solid #c0c0c0;
+  margin: 0 2px;
+  padding: 0.35em 0.625em 0.75em;
+}
+
+/**
+ * 1. Correct `color` not being inherited in IE 8/9/10/11.
+ * 2. Remove padding so people aren't caught out if they zero out fieldsets.
+ */
+
+legend {
+  border: 0; /* 1 */
+  padding: 0; /* 2 */
+}
+
+/**
+ * Remove default vertical scrollbar in IE 8/9/10/11.
+ */
+
+textarea {
+  overflow: auto;
+}
+
+/**
+ * Don't inherit the `font-weight` (applied by a rule above).
+ * NOTE: the default cannot safely be changed in Chrome and Safari on OS X.
+ */
+
+optgroup {
+  font-weight: bold;
+}
+
+/* Tables
+   ========================================================================== */
+
+/**
+ * Remove most spacing between table cells.
+ */
+
+table {
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+
+td,
+th {
+  padding: 0;
+}