First cross try

.gitignore

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

.gitlab-ci.yml

@@ -1,13 +1,8 @@
-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
+  DOCKER_REV: cefaee3c742af193e0f7783f87edb0d35374515c
 
 ############################################################
 # CI Step
@@ -19,53 +14,34 @@ variables:
     - x86_64-linux
   variables:
     OS: "LINUX"
-    ARCH: "64"
 
 .alpine:64bit:
-  image: "alpine:3.12"
+  image: "alpine:edge"
   tags:
     - x86_64-linux
   variables:
     OS: "LINUX"
-    ARCH: "64"
+    BIT: "64"
 
 .alpine:32bit:
-  image: "i386/alpine:3.12"
+  image: "i386/alpine:edge"
   tags:
     - x86_64-linux
   variables:
     OS: "LINUX"
-    ARCH: "32"
+    BIT: "32"
-
-.linux:armv7:
-  image: "arm32v7/fedora"
-  tags:
-    - armv7-linux
-  variables:
-    OS: "LINUX"
-    ARCH: "ARM"
-
-.linux:aarch64:
-  image: "arm64v8/fedora"
-  tags:
-    - aarch64-linux
-  variables:
-    OS: "LINUX"
-    ARCH: "ARM64"
 
 .darwin:
   tags:
     - x86_64-darwin
   variables:
     OS: "DARWIN"
-    ARCH: "64"
 
 .freebsd:
   tags:
     - x86_64-freebsd
   variables:
     OS: "FREEBSD"
-    ARCH: "64"
 
 .root_cleanup:
   after_script:
@@ -81,12 +57,7 @@ variables:
   script:
     - ./.gitlab/script/ghcup_version.sh
   variables:
-    JSON_VERSION: "0.0.4"
+    JSON_VERSION: "0.0.2"
-  artifacts:
-    expire_in: 2 week
-    paths:
-      - golden
-    when: on_failure
 
 .test_ghcup_version:linux:
   extends:
@@ -95,27 +66,6 @@ variables:
   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
@@ -141,131 +91,58 @@ variables:
       - out
   only:
     - tags
-  variables:
-    JSON_VERSION: "0.0.4"
-
-######## 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"
+    GHC_VERSION: "8.6.5"
-    CABAL_VERSION: "3.4.0.0"
+    CABAL_VERSION: "3.2.0.0"
-  needs: []
 
 test:linux:latest:
-  stage: test
   extends: .test_ghcup_version:linux
   variables:
-    GHC_VERSION: "8.10.4"
+    GHC_VERSION: "8.8.3"
-    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: []
+  allow_failure: true
 
-######## 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"
+    GHC_VERSION: "8.6.5"
-    CABAL_VERSION: "3.4.0.0"
+    CABAL_VERSION: "3.2.0.0"
-  needs: []
 
 test:mac:latest:
-  stage: test
   extends: .test_ghcup_version:darwin
   variables:
-    GHC_VERSION: "8.10.4"
+    GHC_VERSION: "8.8.3"
-    CABAL_VERSION: "3.4.0.0"
+    CABAL_VERSION: "3.2.0.0"
-  needs: []
+  allow_failure: true
 
 
 ######## freebsd test ########
 
 test:freebsd:recommended:
-  stage: test
   extends: .test_ghcup_version:freebsd
   variables:
-    GHC_VERSION: "8.10.4"
+    GHC_VERSION: "8.6.5"
-    CABAL_VERSION: "3.4.0.0"
+    CABAL_VERSION: "3.2.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"
+    GHC_VERSION: "8.8.3"
-    CABAL_VERSION: "3.4.0.0"
+    CABAL_VERSION: "3.2.0.0"
-  allow_failure: true # freebsd runners are unreliable
+  allow_failure: true
-  when: manual
-  needs: []
 
 
 ######## linux release ########
 
 release:linux:64bit:
-  stage: release
-  needs: ["test:linux:recommended", "test:linux:latest"]
   extends:
     - .alpine:64bit
     - .release_ghcup
@@ -273,54 +150,25 @@ release:linux:64bit:
     - ./.gitlab/before_script/linux/alpine/install_deps.sh
   variables:
     ARTIFACT: "x86_64-linux-ghcup"
-    GHC_VERSION: "8.10.4"
+    GHC_VERSION: "8.8.3"
-    CABAL_VERSION: "3.4.0.0"
+    CABAL_VERSION: "3.2.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"
+    ARTIFACT: "x86_64-linux-ghcup"
-    GHC_VERSION: "8.10.4"
+    GHC_VERSION: "8.8.3"
     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
@@ -329,16 +177,14 @@ release:darwin:
     - ./.gitlab/before_script/darwin/install_deps.sh
   variables:
     ARTIFACT: "x86_64-apple-darwin-ghcup"
-    GHC_VERSION: "8.10.4"
+    GHC_VERSION: "8.8.3"
-    CABAL_VERSION: "3.4.0.0"
+    CABAL_VERSION: "3.2.0.0"
     MACOSX_DEPLOYMENT_TARGET: "10.7"
 
 
 ######## freebsd release ########
 
 release:freebsd:
-  stage: release
-  needs: ["test:freebsd:recommended", "test:freebsd:latest"]
   extends:
     - .freebsd
     - .release_ghcup
@@ -347,27 +193,5 @@ release:freebsd:
     - ./.gitlab/before_script/freebsd/install_deps.sh
   variables:
     ARTIFACT: "x86_64-portbld-freebsd-ghcup"
-    GHC_VERSION: "8.10.4"
+    GHC_VERSION: "8.6.5"
-    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/before_script/darwin/install_deps.sh

@@ -4,14 +4,11 @@ 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 -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin set ${GHC_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 
 exit 0

.gitlab/before_script/freebsd/install_deps.sh

@@ -6,14 +6,18 @@ set -eux
 
 . "$( 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
+mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+# ./ghcup-bin install ${GHC_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+# ./ghcup-bin install-cabal ${CABAL_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
+# ./ghcup-bin set ${GHC_VERSION}
+
+# install cabal-3.2.0.0
+curl -sSfL -o cabal-install-3.2.0.0-x86_64-portbld-freebsd.tar.xz 'https://hasufell.de/d/d3e215db133e4fcaa61e/files/?p=/cabal-install-3.2.0.0-x86_64-portbld-freebsd.tar.xz&dl=1'
+tar xf cabal-install-3.2.0.0-x86_64-portbld-freebsd.tar.xz
+cp cabal "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin/cabal"
+chmod +x "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin/cabal"
 
 exit 0

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

@@ -4,15 +4,10 @@ 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 \
@@ -21,20 +16,33 @@ apk add --no-cache \
 	tar \
 	perl
 
-if [ "${ARCH}" = "32" ] ; then
+ln -s libncurses.so /usr/lib/libtinfo.so
-	curl -sSfL https://downloads.haskell.org/ghcup/i386-linux-ghcup > ./ghcup-bin
+ln -s libncursesw.so.6 /usr/lib/libtinfow.so.6
+if [ "${BIT}" = "32" ] ; then
+	curl -sSfL https://downloads.haskell.org/~ghcup/0.1.4/i386-linux-ghcup-0.1.4 > ./ghcup-bin
 else
-	curl -sSfL https://downloads.haskell.org/ghcup/x86_64-linux-ghcup > ./ghcup-bin
+	curl -sSfL https://downloads.haskell.org/~ghcup/0.1.4/x86_64-linux-ghcup-0.1.4 > ./ghcup-bin
 fi
 chmod +x ghcup-bin
-./ghcup-bin upgrade -i -f
+./ghcup-bin upgrade
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin install ${GHC_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
+# ./ghcup-bin install-cabal ${CABAL_VERSION}
+# install cabal-3.2.0.0
+if [ "${BIT}" = "32" ] ; then
+	curl -sSfL -o cabal-install-3.2.0.0-i386-alpine-linux-musl.tar.xz 'https://hasufell.de/d/d3e215db133e4fcaa61e/files/?p=/cabal-install-3.2.0.0-i386-alpine-linux-musl.tar.xz&dl=1'
+	tar xf cabal-install-3.2.0.0-i386-alpine-linux-musl.tar.xz
+	cp cabal-install-3.2.0.0-i386-alpine-linux-musl "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin/cabal"
+else
+	curl -sSfL -o cabal-install-3.2.0.0-x86_64-alpine-linux-musl.tar.xz 'https://hasufell.de/d/d3e215db133e4fcaa61e/files/?p=/cabal-install-3.2.0.0-x86_64-alpine-linux-musl.tar.xz&dl=1'
+	tar xf cabal-install-3.2.0.0-x86_64-alpine-linux-musl.tar.xz
+	cp cabal-install-3.2.0.0-x86_64-alpine-linux-musl "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin/cabal"
+fi
+chmod +x "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin/cabal"
+
 
 # utils
 apk add --no-cache \
-	bash \
+	bash
-	git
 
 ## Package specific
 apk add --no-cache \
@@ -46,6 +54,7 @@ apk add --no-cache \
 	openssl-dev \
 	openssl-libs-static \
 	xz \
-	xz-dev \
+	xz-dev
-	ncurses-static
+
+
 

.gitlab/before_script/linux/install_deps.sh

@@ -2,18 +2,15 @@
 
 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 git wget
+sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
 
 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 -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin set ${GHC_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 

.gitlab/before_script/linux/install_deps_manual.sh

@@ -1,64 +0,0 @@
-#!/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
-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

@@ -1,10 +0,0 @@
-#!/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 git wget

.gitlab/ghcup_env

@@ -1,3 +1,3 @@
 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"
+

.gitlab/script/ghcup_bootstrap.sh

@@ -1,30 +0,0 @@
-#!/bin/sh
-
-set -eux
-
-. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
-
-mkdir -p "$CI_PROJECT_DIR"/.local/bin
-
-ecabal() {
-	cabal --store-dir="$(pwd)"/.store "$@"
-}
-
-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

@@ -10,32 +10,17 @@ ecabal() {
 	cabal --store-dir="$(pwd)"/.store "$@"
 }
 
-git describe
-
 # build
 ecabal update
 
 if [ "${OS}" = "LINUX" ] ; then
-	if [ "${ARCH}" = "32" ] ; then
+	ecabal build -w ghc-${GHC_VERSION} -fcurl --ghc-options='-split-sections -optl-static'
-		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" -ftui
 else
-	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
+	ecabal build -w ghc-${GHC_VERSION} -fcurl
 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

@@ -1,21 +0,0 @@
-#!/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

@@ -11,40 +11,22 @@ ecabal() {
 }
 
 eghcup() {
-	ghcup -v -c -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml "$@"
+	ghcup -v -c -s file://$(pwd)/ghcup-${JSON_VERSION}.json "$@"
 }
 
-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 build -w ghc-${GHC_VERSION} -fcurl
-	ecabal test -w ghc-${GHC_VERSION} -ftui ghcup-test
-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
-	else
-		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
-		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
-	fi
 else
-	ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
+	ecabal build -w ghc-${GHC_VERSION}
-	ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
 fi
 
-ecabal haddock -w ghc-${GHC_VERSION} -ftar
+cp "$(ecabal new-exec --enable-tests --verbose=0 --offline sh -- -c 'command -v ghcup')" .
-
+cp "$(ecabal new-exec --enable-tests --verbose=0 --offline sh -- -c 'command -v ghcup-gen')" .
-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
@@ -57,10 +39,16 @@ rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
 ### manual cli based testing
 
 
-ghcup-gen check -f ghcup-${JSON_VERSION}.yaml
+ghcup-gen check -f ghcup-${JSON_VERSION}.json
 
 eghcup --numeric-version
 
+# TODO: rm once we have tarballs
+if [ "${OS}"  = "FREEBSD" ] ; then
+	GHC_VERSION=8.6.3
+	CABAL_VERSION=2.4.1.0
+fi
+
 eghcup install ${GHC_VERSION}
 eghcup set ${GHC_VERSION}
 eghcup install-cabal ${CABAL_VERSION}
@@ -82,38 +70,18 @@ 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 install 8.4.4
-	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.4.4
-eghcup set 8.10.3
+eghcup set 8.4.4
-[ "$(ghc --numeric-version)" = "8.10.3" ]
+[ "$(ghc --numeric-version)" = "8.4.4" ]
 eghcup set ${GHC_VERSION}
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-eghcup rm 8.10.3
+eghcup rm 8.4.4
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
 
-# install hls
-if [ "${OS}" = "DARWIN" ] ; then
-	eghcup install hls
-	haskell-language-server-wrapper --version
-elif [ "${OS}" = "LINUX" ] ; then
-	if [ "${ARCH}" = "64" ] ; then
-		eghcup install hls
-		haskell-language-server-wrapper --version
-	fi
-fi
-
-
 eghcup rm $(ghc --numeric-version)
 
-# https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/116
-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
-
 eghcup upgrade
 eghcup upgrade -f
 

.gitlab/script/hlint.sh

@@ -1,19 +0,0 @@
-#!/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

@@ -1,83 +0,0 @@
-# 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,10 +1,5 @@
 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
@@ -15,13 +10,6 @@ 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:

.travis/build.sh

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

CHANGELOG.md

@@ -1,106 +1,5 @@
 # Revision history for ghcup
 
-## 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

Dockerfile

@@ -0,0 +1,42 @@
+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

@@ -43,33 +43,3 @@ 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

@@ -9,17 +9,8 @@ Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [p
 ## 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)
@@ -43,37 +34,27 @@ 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`.
 
-For the simple interactive TUI, run:
+Common use cases are:
-
-```sh
-ghcup tui
-```
-
-For the full functionality via cli:
 
 ```sh
 # list available ghc/cabal versions
 ghcup list
 
 # install the recommended GHC version
-ghcup install ghc
+ghcup install
 
 # install a specific GHC version
-ghcup install ghc 8.2.2
+ghcup install 8.2.2
 
 # set the currently "active" GHC version
-ghcup set ghc 8.4.4
+ghcup set 8.4.4
 
 # install cabal-install
-ghcup install cabal
+ghcup install-cabal
 
 # update ghcup itself
 ghcup upgrade
@@ -82,75 +63,16 @@ ghcup upgrade
 Generally this is meant to be used 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
+### Bash-completion
 
-Shell completions are in `shell-completions`.
+Depending on your distro and setup, install `.bash-completion` from this repo
-
+as e.g. `/etc/bash_completion.d/ghcup` and make sure your bashrc sources the
-For bash: install `shell-completions/bash`
+startup script (`/usr/share/bash-completion/bash_completion` on some distros).
-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
 
@@ -180,22 +102,10 @@ 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.

RELEASING.md

@@ -1,19 +1,11 @@
 # RELEASING
 
-1. update `GHCup.Version` module. `ghcupURL` must only be updated if we change the `_toolRequirements` type or the YAML representation of it. The version of the YAML represents the change increments. `ghcUpVer` is the current application version.
+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.
 
-2. Update version in ghcup.cabal
+2. Add/fix downloads to `GHCupDownloads` module, then run `ghcup-gen gen` to generate the new json and validate it via `ghcup-gen check`.
 
-3. Add ChangeLog entry
+3. Commit and git push with tag. Wait for tests to succeed.
 
-4. Add/fix downloads in `ghcup-<ver>.yaml`, then verify with `ghcup-gen check -f ghcup-<ver>.yaml`
+4. Upload the new `ghcup-<ver>.json` to `webhost.haskell.org/ghcup/data/`.
 
-5. Commit and git push with tag. Wait for tests to succeed and release artifacts to build.
+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.
-
-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,19 +2,20 @@
 
 ## Now
 
-* ghcup init?
+* try to run exe before upgrade (backup to ~/.ghcup/bin/ghcup.old)
-* merge two download files
+* allow to build 8.8
-* fetch/unpack functionality
+* curl DL does not cache json
+* explain environment variables
+* add --keep=<always|error> option
+
+* allow to switch to curl/wget at runtime
+
+* cross support
 * installing multiple versions of the same
-* post-install
 
 * proper test suite
+* add more logging
 
-* !! 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
 

app/ghcup-gen/Main.hs

@@ -10,11 +10,13 @@
 
 module Main where
 
+import           GHCup.Data.GHCupInfo
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.Logger
 
-import           Data.Char                      ( toLower )
+import           Data.Aeson                     ( eitherDecode, encode )
+import           Data.Aeson.Encode.Pretty
 #if !MIN_VERSION_base(4,13,0)
 import           Data.Semigroup                 ( (<>) )
 #endif
@@ -22,19 +24,51 @@ 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.Yaml                     as Y
+import qualified Data.ByteString.Lazy          as L
 
 
 data Options = Options
   { optCommand :: Command
   }
 
-data Command = ValidateYAML ValidateYAMLOpts
+data Command = GenJSON GenJSONOpts
-             | ValidateTarballs ValidateYAMLOpts TarballFilter
+             | 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 Input
@@ -44,10 +78,11 @@ 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'
@@ -57,73 +92,81 @@ stdInput = flag'
 inputP :: Parser Input
 inputP = fileInput <|> stdInput
 
-data ValidateYAMLOpts = ValidateYAMLOpts
+data ValidateJSONOpts = ValidateJSONOpts
-  { vInput :: Maybe Input
+  { input :: Maybe Input
   }
 
-validateYAMLOpts :: Parser ValidateYAMLOpts
+validateJSONOpts :: Parser ValidateJSONOpts
-validateYAMLOpts = ValidateYAMLOpts <$> optional inputP
+validateJSONOpts = ValidateJSONOpts <$> 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
+  (  (command
+       "gen"
+       (   GenJSON
+       <$> (info (genJSONOpts <**> helper)
+                 (progDesc "Generate the json downloads file")
+           )
+       )
+     )
+  <> (command
        "check"
-       (   ValidateYAML
+       (   ValidateJSON
-       <$> info (validateYAMLOpts <**> helper)
+       <$> (info (validateJSONOpts <**> helper)
-                (progDesc "Validate the YAML")
+                 (progDesc "Validate the JSON")
+           )
        )
-  <> command
+     )
+  <> (command
        "check-tarballs"
-       (info
+       (   ValidateTarballs
-         ((ValidateTarballs <$> validateYAMLOpts <*> tarballFilterP) <**> helper)
+       <$> (info
-         (progDesc "Validate all tarballs (download and checksum)")
+             (validateJSONOpts <**> 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
-          ValidateYAML vopts -> case vopts of
+          GenJSON gopts -> do
-            ValidateYAMLOpts { vInput = Nothing } ->
+            let bs True =
-              B.getContents >>= valAndExit validate
+                  encodePretty' (defConfig { confIndent = Spaces 2 }) ghcupInfo
-            ValidateYAMLOpts { vInput = Just StdInput } ->
+                bs False = encode ghcupInfo
-              B.getContents >>= valAndExit validate
+            case gopts of
-            ValidateYAMLOpts { vInput = Just (FileInput file) } ->
+              GenJSONOpts { output = Nothing, pretty } ->
-              B.readFile file >>= valAndExit validate
+                L.hPutStr stdout (bs pretty)
-          ValidateTarballs vopts tarballFilter -> case vopts of
+              GenJSONOpts { output = Just StdOutput, pretty } ->
-            ValidateYAMLOpts { vInput = Nothing } ->
+                L.hPutStr stdout (bs pretty)
-              B.getContents >>= valAndExit (validateTarballs tarballFilter)
+              GenJSONOpts { output = Just (FileOutput file), pretty } ->
-            ValidateYAMLOpts { vInput = Just StdInput } ->
+                L.writeFile file (bs pretty)
-              B.getContents >>= valAndExit (validateTarballs tarballFilter)
+          ValidateJSON vopts -> case vopts of
-            ValidateYAMLOpts { vInput = Just (FileInput file) } ->
+            ValidateJSONOpts { input = Nothing } ->
-              B.readFile file >>= valAndExit (validateTarballs tarballFilter)
+              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
   pure ()
 
  where
   valAndExit f contents = do
-    (GHCupInfo _ av) <- case Y.decodeEither' contents of
+    (GHCupInfo _ av) <- case eitherDecode contents of
       Right r -> pure r
       Left  e -> die (color Red $ show e)
     myLoggerT (LoggerConfig True (B.hPut stdout) (\_ -> pure ())) (f av)

app/ghcup-gen/Validate.hs

@@ -1,27 +1,14 @@
-{-# LANGUAGE CPP              #-}
+{-# LANGUAGE TemplateHaskell  #-}
-{-# 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.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.Exception.Safe
 import           Control.Monad
 import           Control.Monad.IO.Class
@@ -32,20 +19,15 @@ 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           HPath                          ( toFilePath )
 import           Haskus.Utils.Variant.Excepts
 import           Optics
 import           System.Exit
 import           System.IO
-import           System.Posix.FilePath
 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
@@ -71,7 +53,7 @@ validate :: (Monad m, MonadLogger m, MonadThrow m, MonadIO m, MonadUnliftIO m)
 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
@@ -80,7 +62,7 @@ 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 (_viTags vi) arch (M.keys pspecs)
+          checkHasRequiredPlatforms t v arch (M.keys pspecs)
 
     checkGHCVerIsValid
     forM_ (M.toList dls) $ \(t, _) -> checkMandatoryTags t
@@ -94,30 +76,17 @@ validate dls = do
         lift $ $(logInfo) [i|All good|]
         pure ExitSuccess
  where
-  checkHasRequiredPlatforms t v tags arch pspecs = do
+  checkHasRequiredPlatforms t v arch pspecs = do
     let v' = prettyVer v
-        arch' = prettyShow arch
+    when (not $ any (== Linux UnknownLinux) pspecs) $ do
-    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 ((notElem Darwin pspecs) && arch == A_64) $ do
+    when ((not $ any (== Darwin) pspecs) && arch == A_64) $ do
-      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch'}|]
+      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch}|]
       addError
-    when ((notElem FreeBSD pspecs) && arch == A_64) $ lift $ $(logWarn)
+    when ((not $ any (== FreeBSD) pspecs) && arch == A_64) $ lift $ $(logWarn)
-      [i|FreeBSD missing for #{t} #{v'} #{arch'}|]
+      [i|FreeBSD missing for #{t} #{v'} #{arch}|]
-
-    -- 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 $ M.elems $ availableToolVersions dls tool
@@ -128,7 +97,7 @@ validate dls = do
                     (\case
                       [] -> throwM $ InternalError "empty inner list"
                       (t : ts) ->
-                        pure $ (t, ) (not (isUniqueTag t) || null ts)
+                        pure $ (t, ) $ if isUniqueTag t then ts == [] else True
                     )
                 . group
                 . sort
@@ -142,8 +111,6 @@ validate dls = do
    where
     isUniqueTag Latest         = True
     isUniqueTag Recommended    = True
-    isUniqueTag Old            = False
-    isUniqueTag Prerelease     = False
     isUniqueTag (Base       _) = False
     isUniqueTag (UnknownTag _) = False
 
@@ -177,11 +144,6 @@ validate dls = do
   isBase (Base _) = True
   isBase _        = False
 
-data TarballFilter = TarballFilter
-  { tfTool    :: Maybe Tool
-  , tfVersion :: Regex
-  }
-
 validateTarballs :: ( Monad m
                     , MonadLogger m
                     , MonadThrow m
@@ -189,20 +151,23 @@ validateTarballs :: ( Monad m
                     , MonadUnliftIO m
                     , MonadMask m
                     )
-                 => TarballFilter
+                 => GHCupDownloads
-                 -> GHCupDownloads
                  -> m ExitCode
-validateTarballs (TarballFilter tool versionRegex) dls = do
+validateTarballs dls = do
   ref <- liftIO $ newIORef 0
 
   flip runReaderT ref $ do
-     -- download/verify all tarballs
+     -- download/verify all binary tarballs
-    let dlis = nubOrd $ dls ^.. each
+    let
-          %& indices (maybe (const True) (==) tool) %> each
+      dlbis = nub $ join $ (M.elems dls) <&> \versions ->
-          %& indices (matchTest versionRegex . T.unpack . prettyVer)
+        join $ (M.elems versions) <&> \vi ->
-          % (viSourceDL % _Just `summing` viArch % each % each % each)
+          join $ (M.elems $ _viArch vi) <&> \pspecs ->
-    when (null dlis) $ $(logError) [i|no tarballs selected by filter|] *> addError
+            join $ (M.elems pspecs) <&> \pverspecs -> (M.elems pverspecs)
-    forM_ dlis downloadAll
+    forM_ dlbis $ downloadAll
+
+    let dlsrc = nub $ join $ (M.elems dls) <&> \versions ->
+          join $ (M.elems versions) <&> maybe [] (: []) . _viSourceDL
+    forM_ dlsrc $ downloadAll
 
     -- exit
     e <- liftIO $ readIORef ref
@@ -213,55 +178,21 @@ validateTarballs (TarballFilter tool versionRegex) dls = do
         pure ExitSuccess
 
  where
-  runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
-                                     , colorOutter  = B.hPut stderr
-                                     , rawOutter    = \_ -> pure ()
-                                     }
   downloadAll dli = do
-    dirs <- liftIO getDirs
+    let settings = Settings True False Never
-    let settings = AppState (Settings True False Never Curl False GHCupURL) dirs defaultKeyBindings
+    let runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
+                                           , colorOutter  = B.hPut stderr
+                                           , rawOutter    = (\_ -> pure ())
+                                           }
 
     r <-
       runLogger
       . flip runReaderT settings
       . runResourceT
-      . runE @'[DigestError
+      . runE
-               , DownloadFailed
+      $ downloadCached dli Nothing
-               , UnknownArchive
-#if defined(TAR)
-               , Tar.FormatError
-#else
-               , ArchiveResult
-#endif
-               ]
-      $ do
-        p <- liftE $ downloadCached dli Nothing
-        fmap (head . splitDirectories . head)
-          . liftE
-          . getArchiveFiles
-          $ p
     case r of
-      VRight basePath -> do
+      VRight _ -> pure ()
-        case _dlSubdir dli of
-          Just (RealDir (toFilePath -> 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 ()
       VLeft  e -> do
         lift $ $(logError)
           [i|Could not download (or verify hash) of #{dli}, Error was: #{e}|]

app/ghcup/BrickMain.hs

@@ -1,605 +0,0 @@
-{-# LANGUAGE CPP               #-}
-{-# LANGUAGE DataKinds         #-}
-{-# LANGUAGE FlexibleContexts  #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes       #-}
-{-# LANGUAGE TemplateHaskell   #-}
-{-# LANGUAGE TypeApplications  #-}
-{-# LANGUAGE ViewPatterns      #-}
-
-module BrickMain where
-
-import           GHCup
-import           GHCup.Download
-import           GHCup.Errors
-import           GHCup.Types
-import           GHCup.Utils
-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.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
-
-
-
-data BrickData = BrickData
-  { lr    :: [ListResult]
-  , dls   :: GHCupDownloads
-  , pfreq :: PlatformRequest
-  }
-  deriving Show
-
-data BrickSettings = BrickSettings
-  { showAll :: 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 set')
-  , (bChangelog, const "ChangeLog", withIOAction changelog')
-  , ( bShowAll
-    , \BrickSettings {..} ->
-       if showAll then "Hide old versions" else "Show all versions"
-    , hideShowHandler
-    )
-  , (bUp, const "Up", \BrickState {..} -> continue BrickState{ appState = moveCursor 1 appState Up, .. })
-  , (bDown, const "Down", \BrickState {..} -> continue BrickState{ appState = moveCursor 1 appState Down, .. })
-  ]
- where
-  hideShowHandler BrickState{..} =
-    let newAppSettings   = appSettings { showAll = not . showAll $ 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"
-
-  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) -> IO (Either String a))
-             -> BrickState
-             -> EventM n (Next BrickState)
-withIOAction action as = case listSelectedElement' (appState as) of
-  Nothing      -> continue as
-  Just (ix, e) -> suspendAndResume $ do
-    action as (ix, e) >>= \case
-      Left  err -> putStrLn ("Error: " <> err)
-      Right _   -> putStrLn "Success"
-    getAppData Nothing (pfreq . appData $ as) >>= \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 (showAll 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 -> ListResult -> Bool
-filterVisible showAll e | lInstalled e = True
-                        | showAll      = True
-                        | otherwise    = not (elem Old (lTag e))
-
-
-install' :: BrickState -> (Int, ListResult) -> IO (Either String ())
-install' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
-  settings <- readIORef settings'
-  l        <- readIORef logger'
-  let runLogger = myLoggerT l
-
-  let run =
-        runLogger
-          . flip runReaderT settings
-          . 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 dls lVer pfreq $> vi
-        Cabal -> do
-          let vi = getVersionInfo lVer Cabal dls
-          liftE $ installCabalBin dls lVer pfreq $> vi
-        GHCup -> do
-          let vi = snd <$> getLatest dls GHCup
-          liftE $ upgradeGHCup dls Nothing False pfreq $> vi
-        HLS   -> do
-          let vi = getVersionInfo lVer HLS dls
-          liftE $ installHLSBin dls lVer pfreq $> vi
-    )
-    >>= \case
-          VRight vi                         -> do
-            forM_ (_viPostInstall =<< vi) $ \msg ->
-              runLogger $ $(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 $> ()
-        GHCup -> pure ()
-    )
-    >>= \case
-          VRight _ -> pure $ Right ()
-          VLeft  e -> pure $ Left (prettyShow e)
-
-
-del' :: BrickState -> (Int, ListResult) -> IO (Either String ())
-del' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
-  settings <- readIORef settings'
-  l        <- readIORef logger'
-  let runLogger = myLoggerT l
-
-  let run = runLogger . flip runReaderT settings . 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
-        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' :: BrickState -> (Int, ListResult) -> IO (Either String ())
-changelog' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
-  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"
-      exec cmd True [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
-
-
-
-logger' :: IORef LoggerConfig
-{-# NOINLINE logger' #-}
-logger' = unsafePerformIO
-  (newIORef $ LoggerConfig { lcPrintDebug = False
-                           , colorOutter  = \_ -> pure ()
-                           , rawOutter    = \_ -> pure ()
-                           }
-  )
-
-
-brickMain :: AppState
-          -> LoggerConfig
-          -> GHCupDownloads
-          -> PlatformRequest
-          -> IO ()
-brickMain s l av pfreq' = do
-  writeIORef settings' s
-  -- logger interpreter
-  writeIORef logger'   l
-  let runLogger = myLoggerT l
-
-  no_color <- isJust <$> lookupEnv "NO_COLOR"
-
-  eAppData <- getAppData (Just av) pfreq'
-  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 { showAll = False }
-
-
-getDownloads' :: IO (Either String GHCupDownloads)
-getDownloads' = do
-  settings <- readIORef settings'
-  l        <- readIORef logger'
-  let runLogger = myLoggerT l
-
-  r <-
-    runLogger
-    . flip runReaderT settings
-    . runE @'[JSONError , DownloadFailed , FileDoesNotExistError]
-    $ fmap _ghcupDownloads
-    $ liftE
-    $ getDownloadsF (urlSource . GT.settings $ settings)
-
-  case r of
-    VRight a -> pure $ Right a
-    VLeft  e -> pure $ Left (prettyShow e)
-
-
-getAppData :: Maybe GHCupDownloads
-           -> PlatformRequest
-           -> IO (Either String BrickData)
-getAppData mg pfreq' = do
-  settings <- readIORef settings'
-  l        <- readIORef logger'
-  let runLogger = myLoggerT l
-
-  r <- maybe getDownloads' (pure . Right) mg
-
-  runLogger . flip runReaderT settings $ do
-    case r of
-      Right dls -> do
-        lV <- listVersions dls Nothing Nothing pfreq'
-        pure $ Right $ BrickData (reverse lV) dls pfreq'
-      Left e -> pure $ Left [i|#{e}|]
-

bootstrap-haskell

@@ -1,99 +1,40 @@
 #!/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}"
 
-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
-
-: "${BOOTSTRAP_HASKELL_GHC_VERSION:=recommended}"
-: "${BOOTSTRAP_HASKELL_CABAL_VERSION:=recommended}"
-
 die() {
     (>&2 printf "\\033[0;31m%s\\033[0m\\n" "$1")
     exit 2
 }
 
-edo() {
+edo()
+{
     "$@" || die "\"$*\" failed!"
 }
 
 eghcup() {
-	edo _eghcup "$@"
-}
-
-_eghcup() {
     if [ -z "${BOOTSTRAP_HASKELL_VERBOSE}" ] ; then
-        ghcup "$@"
+        edo ghcup "$@"
     else
-        ghcup --verbose "$@"
+        edo ghcup --verbose "$@"
     fi
 }
 
-_done() {
-	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, run:"
-	echo "  ghcup tui"
-
-	exit 0
-}
-
 download_ghcup() {
 	_plat="$(uname -s)"
 	_arch=$(uname -m)
-	_ghver="0.1.14"
-	_base_url="https://downloads.haskell.org/~ghcup"
 
     case "${_plat}" in
         "linux"|"Linux")
 			case "${_arch}" in
 				x86_64|amd64)
-					# we could be in a 32bit docker container, in which
+					_url=https://downloads.haskell.org/~ghcup/0.1.4/x86_64-linux-ghcup-0.1.4
-					# 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=${_base_url}/${_ghver}/i386-linux-ghcup-${_ghver}
+					_url=https://downloads.haskell.org/~ghcup/0.1.4/i386-linux-ghcup-0.1.4
-					;;
-				armv7*)
-					_url=${_base_url}/${_ghver}/armv7-linux-ghcup-${_ghver}
-					;;
-				aarch64|arm64|armv8l)
-					_url=${_base_url}/${_ghver}/aarch64-linux-ghcup-${_ghver}
 					;;
 				*) die "Unknown architecture: ${_arch}"
 					;;
@@ -109,7 +50,7 @@ download_ghcup() {
 				*) die "Unknown architecture: ${_arch}"
 					;;
 			esac
-			_url=${_base_url}/${_ghver}/x86_64-portbld-freebsd-ghcup-${_ghver}
+			_url=https://downloads.haskell.org/~ghcup/0.1.4/x86_64-portbld-freebsd-ghcup-0.1.4
             ;;
         "Darwin"|"darwin")
 			case "${_arch}" in
@@ -121,48 +62,30 @@ download_ghcup() {
 				*) die "Unknown architecture: ${_arch}"
 					;;
 			esac
-			_url=${_base_url}/${_ghver}/x86_64-apple-darwin-ghcup-${_ghver} ;;
+			_url=https://downloads.haskell.org/~ghcup/0.1.4/x86_64-apple-darwin-ghcup-0.1.4 ;;
         *) die "Unknown platform: ${_plat}"
 			;;
     esac
 
-	edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup
+	edo curl -Lf "${_url}" > "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/ghcup
 
-    edo chmod +x "${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
-
-	unset _plat _arch _url _ghver _base_url
 }
 
 
 echo
 echo "Welcome to Haskell!"
 echo
-echo "This script will download and install the following binaries:"
+echo "This will download and install the Glasgow Haskell Compiler (GHC)"
-echo "  * ghcup - The Haskell toolchain installer"
+echo "and the Cabal build tool."
-echo "            (for managing GHC/cabal versions)"
-echo "  * ghc   - The Glasgow Haskell Compiler"
-echo "  * cabal - The Cabal build tool"
 echo
-if [ -z "${GHCUP_USE_XDG_DIRS}" ] ; then
+echo "ghcup installs only into the following directory, which can be removed anytime:"
-	echo "ghcup installs only into the following directory,"
+echo "  $GHCUP_INSTALL_BASE_PREFIX/.ghcup"
-    echo "which can be removed anytime:"
-	echo "  $GHCUP_INSTALL_BASE_PREFIX/.ghcup"
-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 or ctrl-c to abort."
+    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."
     echo
     # Wait for user input to continue.
@@ -170,14 +93,22 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
     read -r answer </dev/tty
 fi
 
-edo mkdir -p "${GHCUP_BIN}"
+edo mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
 
 if command -V "ghcup" >/dev/null 2>&1 ; then
     if [ -z "${BOOTSTRAP_HASKELL_NO_UPGRADE}" ] ; then
-        _eghcup upgrade || download_ghcup
+        eghcup upgrade
     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
+    eghcup upgrade
 fi
 
 echo
@@ -185,7 +116,8 @@ echo "$(ghcup tool-requirements)"
 echo
 
 if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-    printf "\\033[0;35m%s\\033[0m\\n" "Press ENTER to proceed or ctrl-c to abort."
+    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."
     echo
 
@@ -194,10 +126,10 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
     read -r answer </dev/tty
 fi
 
-eghcup --cache install ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
+eghcup --cache install
 
-eghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
+eghcup set
-eghcup --cache install cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
+eghcup --cache install-cabal
 
 edo cabal new-update
 
@@ -205,32 +137,9 @@ 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
-	printf "\\033[0;35m%s\\033[0m\\n" "Do you want to install haskell-language-server (HLS) now?"
-	printf "\\033[0;35m%s\\033[0m\\n" "HLS is a language-server that provides IDE-like functionality"
-	printf "\\033[0;35m%s\\033[0m\\n" "and can integrate with different editors, such as Vim, Emacs, VS Code, Atom, ..."
-	printf "\\033[0;35m%s\\033[0m\\n" "Also see https://github.com/haskell/haskell-language-server/blob/master/README.md"
-	printf "\\033[0;35m%s\\033[0m\\n" ""
-	printf "\\033[0;35m%s\\033[0m\\n" "Answer with YES or NO and press ENTER."
-	printf "\\033[0;35m%s\\033[0m\\n" ""
-
-	while true; do
-		read -r hls_answer </dev/tty
-
-		case $hls_answer in
-			[Yy]*)
-				eghcup --cache install hls
-				break ;;
-			[Nn]*)
-				break ;;
-			*)
-				echo "Please type YES or NO 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_DIR/env' in your shell"
+    echo "You may want to source '$GHCUP_INSTALL_BASE_PREFIX/.ghcup/env' in your shell"
     echo "configuration to do so (e.g. ~/.bashrc)."
 
 	case $SHELL in
@@ -238,23 +147,30 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 			GHCUP_PROFILE_FILE="$HOME/.zshrc"
 			MY_SHELL="zsh" ;;
 		*/bash) # login shell is bash
-			GHCUP_PROFILE_FILE="$HOME/.bashrc"
+			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
+
 			MY_SHELL="bash" ;;
 		*/sh) # login shell is sh, but might be a symlink to bash or zsh
 			if [ -n "${BASH}" ] ; then
-				GHCUP_PROFILE_FILE="$HOME/.bashrc"
+				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
+
 				MY_SHELL="bash"
 			elif [ -n "${ZSH_VERSION}" ] ; then
 				GHCUP_PROFILE_FILE="$HOME/.zshrc"
 				MY_SHELL="zsh"
 			else
-			    _done
+				exit 0
 			fi
 			;;
-		*/fish) # login shell is fish
+		*) exit 0 ;;
-			GHCUP_PROFILE_FILE="$HOME/.config/fish/config.fish"
-			MY_SHELL="fish" ;;
-		*) _done ;;
 	esac
 
 
@@ -269,41 +185,12 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 
         case $next_answer in
             [Yy]*)
-				case $MY_SHELL in
+                echo "[ -f \"\${GHCUP_INSTALL_BASE_PREFIX:=\$HOME}/.ghcup/env\" ] && source \"\${GHCUP_INSTALL_BASE_PREFIX:=\$HOME}/.ghcup/env\"" >> "${GHCUP_PROFILE_FILE}"
-					"") 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 "$(uname -s)" 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
                 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_DIR}/env\" to apply them in your current terminal session."
+                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."
-				_done
+                exit 0;;
-                ;;
             [Nn]*)
-                _done ;;
+                exit 0;;
             *)
                 echo "Please type YES or NO and press enter.";;
         esac

cabal.ghc8104.project

@@ -1,20 +0,0 @@
-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

@@ -1,261 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,262 +0,0 @@
-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

@@ -7,12 +7,10 @@ package streamly
 
 package ghcup
     ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
-    tests: True
+
-    flags: +tui
+package tar-bytestring
+    ghc-options: -O2
 
 constraints: http-io-streams -brotli
 
-package libarchive
+allow-newer: base
-  flags: -system-libarchive
-
-allow-newer: base, ghc-prim, template-haskell

config.yaml

@@ -1,61 +0,0 @@
-# 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'
-
-# 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

@@ -0,0 +1,14 @@
+#!/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,46 +1,284 @@
-cabal-version:   3.0
+cabal-version:      3.0
-name:            ghcup
+name:               ghcup
-version:         0.1.14
+version:            0.1.4
-license:         LGPL-3.0-only
+synopsis:           ghc toolchain installer as an exe/library
-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 as an exe/library
 description:
   A rewrite of the shell script ghcup, for providing
   a more stable user experience and exposing an API.
 
-category:        System
+homepage:           https://gitlab.haskell.org/haskell/ghcup-hs
-build-type:      Simple
+bug-reports:        https://gitlab.haskell.org/haskell/ghcup-hs/issues
-extra-doc-files: CHANGELOG.md
+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
 
 source-repository head
   type:     git
   location: https://gitlab.haskell.org/haskell/ghcup-hs.git
 
-flag tui
+flag Curl
-  description: Build the brick powered tui (ghcup tui)
+  description: Use curl instead of http-io-streams for download
   default:     False
   manual:      True
 
-flag internal-downloader
+common HsOpenSSL
-  description:
+  build-depends: HsOpenSSL >=0.11.4.18
-    Compile the internal downloader, which links against OpenSSL
 
-  default:     False
+common aeson
-  manual:      True
+  build-depends: aeson >=1.4
 
-flag tar
+common aeson-pretty
-  description: Use tar-bytestring instead of libarchive
+  build-depends: aeson-pretty >=0.8.8
-  default:     False
+
-  manual:      True
+common ascii-string
+  build-depends: ascii-string >=1.0
+
+common async
+  build-depends: async >=0.8
+
+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
 
 library
+  import:
+    config
+    , base
+    , base16-bytestring
+    , aeson
+    , ascii-string
+    , async
+    , 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
+    , megaparsec
+    , 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.Data.GHCupDownloads
+    GHCup.Data.GHCupInfo
+    GHCup.Data.ToolRequirements
     GHCup.Download
     GHCup.Download.Utils
     GHCup.Errors
@@ -50,6 +288,7 @@ library
     GHCup.Types.JSON
     GHCup.Types.Optics
     GHCup.Utils
+    GHCup.Utils.Bash
     GHCup.Utils.Dirs
     GHCup.Utils.File
     GHCup.Utils.Logger
@@ -59,242 +298,91 @@ library
     GHCup.Utils.Version.QQ
     GHCup.Version
 
-  hs-source-dirs:     lib
+  -- other-modules:
-  other-modules:      Paths_ghcup
+  -- other-extensions:
-  autogen-modules:    Paths_ghcup
+  hs-source-dirs:  lib
-  default-language:   Haskell2010
-  default-extensions:
-    LambdaCase
-    MultiWayIf
-    PackageImports
-    RecordWildCards
-    ScopedTypeVariables
-    Strict
-    StrictData
-    TupleSections
 
-  ghc-options:
+  if !flag(curl)
-    -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns
+    import:
-    -fwarn-incomplete-record-updates
+      , HsOpenSSL
-
+      , http-io-streams
-  build-depends:
+      , io-streams
-    , aeson                 >=1.4        && <1.6
+      , terminal-progress-bar
-    , ascii-string          ^>=1.0
-    , 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
-    , bz2                   >=0.5.0.5    && <1.1
-    , 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
-    , generics-sop          ^>=0.5
-    , haskus-utils-types    ^>=1.5
-    , haskus-utils-variant  >=3.0        && <3.2
-    , hpath                 >=0.11       && <0.13
-    , hpath-directory       ^>=0.14.1
-    , hpath-filepath        ^>=0.10.3
-    , hpath-io              ^>=0.14.1
-    , hpath-posix           ^>=0.13.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
-    , streamly              ^>=0.7.3
-    , streamly-bytestring   ^>=0.1.2
-    , streamly-posix        ^>=0.1.0.0
-    , strict-base           ^>=0.4
-    , string-interpolate    >=0.2.0.0    && <0.4
-    , template-haskell      >=2.7        && <2.17
-    , text                  ^>=1.2.4.0
-    , time                  ^>=1.9.3
-    , transformers          ^>=0.5
-    , unix                  ^>=2.7
-    , unix-bytestring       ^>=0.3
-    , unordered-containers  ^>=0.2.10.0
-    , uri-bytestring        ^>=0.3.2.2
-    , utf8-string           ^>=1.0
-    , vector                ^>=0.12
-    , versions              ^>=4.0.1
-    , vty                   >=5.28.2     && <5.34
-    , word8                 ^>=0.1.3
-    , yaml                  ^>=0.11.4.0
-    , zlib                  ^>=0.6.2.2
-
-  if flag(internal-downloader)
     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
-      , terminal-progress-bar  >=0.4.1
-
-  if flag(tar)
-    cpp-options:   -DTAR
-    build-depends: tar-bytestring ^>=0.6.3.1
-
   else
-    build-depends: libarchive ^>=3.0.0.0
+    cpp-options:     -DCURL
 
 executable ghcup
-  main-is:            Main.hs
+  import:
-  hs-source-dirs:     app/ghcup
+    config
-  default-language:   Haskell2010
+    , base
-  default-extensions:
+    , bytestring
-    LambdaCase
+    , containers
-    MultiWayIf
+    , haskus-utils-variant
-    PackageImports
+    , hpath
-    RecordWildCards
+    , hpath-io
-    ScopedTypeVariables
+    , megaparsec
-    Strict
+    , monad-logger
-    StrictData
+    , mtl
-    TupleSections
+    , optparse-applicative
+    , pretty-terminal
+    , resourcet
+    , safe
+    , string-interpolate
+    , table-layout
+    , template-haskell
+    , text
+    , uri-bytestring
+    , utf8-string
+    , versions
 
-  ghc-options:
+  --
-    -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns
+  main-is:          Main.hs
-    -fwarn-incomplete-record-updates -threaded
 
-  build-depends:
+  -- other-modules:
-    , aeson                 >=1.4      && <1.6
+  -- other-extensions:
-    , base                  >=4.13     && <5
+  build-depends:    ghcup
-    , bytestring            ^>=0.10
+  hs-source-dirs:   app/ghcup
-    , containers            ^>=0.6
+  default-language: Haskell2010
-    , ghcup
-    , haskus-utils-variant  >=3.0      && <3.2
-    , hpath                 >=0.11     && <0.13
-    , hpath-io              ^>=0.14.1
-    , 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.17
-    , 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)
-    cpp-options:   -DBRICK
-    other-modules: BrickMain
-    build-depends:
-      , brick   >=0.5    && <0.62
-      , vector  ^>=0.12
-      , vty     >=5.28.2 && <5.34
-
-  if flag(tar)
-    cpp-options: -DTAR
-
-  else
-    build-depends: libarchive ^>=3.0.0.0
 
 executable ghcup-gen
-  main-is:            Main.hs
+  import:
-  hs-source-dirs:     app/ghcup-gen
+    config
-  other-modules:      Validate
+    , base
-  default-language:   Haskell2010
+    , aeson
-  default-extensions:
+    , aeson-pretty
-    LambdaCase
+    , bytestring
-    MultiWayIf
+    , containers
-    PackageImports
+    , haskus-utils-variant
-    RecordWildCards
+    , hpath
-    ScopedTypeVariables
+    , monad-logger
-    TupleSections
+    , mtl
+    , optics
+    , optparse-applicative
+    , pretty-terminal
+    , resourcet
+    , safe-exceptions
+    , string-interpolate
+    , table-layout
+    , text
+    , transformers
+    , uri-bytestring
+    , utf8-string
+    , versions
 
-  ghc-options:
+  --
-    -Wall -fwarn-tabs -fwarn-incomplete-uni-patterns
+  main-is:          Main.hs
-    -fwarn-incomplete-record-updates -threaded
+  other-modules:
+    Validate
 
-  build-depends:
+  -- other-extensions:
-    , aeson                 >=1.4      && <1.6
+  build-depends:    ghcup
-    , aeson-pretty          ^>=0.8.8
+  hs-source-dirs:   app/ghcup-gen
-    , base                  >=4.13     && <5
+  default-language: Haskell2010
-    , bytestring            ^>=0.10
-    , containers            ^>=0.6
-    , ghcup
-    , haskus-utils-variant  >=3.0      && <3.2
-    , hpath                 >=0.11     && <0.13
-    , hpath-filepath        ^>=0.10.3
-    , 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
-    , utf8-string           ^>=1.0
-    , versions              ^>=4.0.1
-    , yaml                  ^>=0.11.4.0
-
-  if flag(tar)
-    cpp-options:   -DTAR
-    build-depends: tar-bytestring ^>=0.6.3.1
-
-  else
-    build-depends: libarchive ^>=3.0.0.0
 
 test-suite ghcup-test
-  type:               exitcode-stdio-1.0
+  default-language: Haskell2010
-  main-is:            Main.hs
+  type:             exitcode-stdio-1.0
-  hs-source-dirs:     test
+  hs-source-dirs:   test
-  other-modules:
+  main-is:          MyLibTest.hs
-    GHCup.ArbitraryTypes
+  build-depends:    base >=4.12.0.0
-    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
-    , hpath                     >=0.11    && <0.13
-    , hspec                     ^>=2.7.4
-    , hspec-golden-aeson        >=0.7     && <0.10
-    , 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

@@ -1,10 +0,0 @@
-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/Data/GHCupInfo.hs

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

lib/GHCup/Data/ToolRequirements.hs

@@ -0,0 +1,94 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes       #-}
+
+module GHCup.Data.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"
+                  ]
+                  ""
+                )
+              ]
+            )
+          ]
+        )
+      ]
+    )
+  ]

lib/GHCup/Download.hs

@@ -9,26 +9,9 @@
 {-# LANGUAGE TypeFamilies          #-}
 
 
-{-|
-Module      : GHCup.Download
-Description : Downloading
-Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
-Maintainer  : hasufell@hasufell.de
-Stability   : experimental
-Portability : POSIX
-
-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(INTERNAL_DOWNLOADER)
+#if !defined(CURL)
 import           GHCup.Download.IOStreams
 import           GHCup.Download.Utils
 #endif
@@ -52,24 +35,21 @@ import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
                                          hiding ( throwM )
 import           Data.Aeson
-import           Data.Bifunctor
+#if !defined(CURL)
 import           Data.ByteString                ( ByteString )
-#if defined(INTERNAL_DOWNLOADER)
 import           Data.CaseInsensitive           ( CI )
 #endif
-import           Data.List                      ( find )
 import           Data.Maybe
 import           Data.String.Interpolate
 import           Data.Time.Clock
 import           Data.Time.Clock.POSIX
-#if defined(INTERNAL_DOWNLOADER)
+#if !defined(CURL)
 import           Data.Time.Format
 #endif
 import           Data.Versions
-import           Data.Word8
 import           GHC.IO.Exception
 import           HPath
-import           HPath.IO                     as HIO hiding ( hideError )
+import           HPath.IO                      as HIO
 import           Haskus.Utils.Variant.Excepts
 import           Optics
 import           Prelude                 hiding ( abs
@@ -77,20 +57,17 @@ import           Prelude                 hiding ( abs
                                                 , writeFile
                                                 )
 import           System.IO.Error
-import           System.Posix.Env.ByteString    ( getEnv )
 import           URI.ByteString
 
 import qualified Crypto.Hash.SHA256            as SHA256
-import qualified Data.ByteString               as BS
 import qualified Data.ByteString.Base16        as B16
 import qualified Data.ByteString.Lazy          as L
-import qualified Data.Map.Strict               as M
+#if !defined(CURL)
-#if defined(INTERNAL_DOWNLOADER)
 import qualified Data.CaseInsensitive          as CI
+import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 #endif
 import qualified Data.Text.Encoding            as E
-import qualified Data.Yaml                     as Y
 import qualified System.Posix.Files.ByteString as PF
 import qualified System.Posix.RawFilePath.Directory
                                                as RD
@@ -105,77 +82,30 @@ import qualified System.Posix.RawFilePath.Directory
     ------------------
 
 
-
 -- | Downloads the download information! But only if we need to ;P
-getDownloadsF :: ( FromJSONKey Tool
+getDownloads :: ( FromJSONKey Tool
-                 , FromJSONKey Version
+                , FromJSONKey Version
-                 , FromJSON VersionInfo
+                , FromJSON VersionInfo
-                 , MonadIO m
+                , MonadIO m
-                 , MonadCatch m
+                , MonadCatch m
-                 , MonadLogger m
+                , MonadLogger m
-                 , MonadThrow m
+                , MonadThrow m
-                 , MonadFail m
+                , MonadFail m
-                 , MonadReader AppState m
+                )
-                 )
+             => URLSource
-              => URLSource
+             -> Excepts '[JSONError , DownloadFailed] m GHCupInfo
-              -> Excepts
+getDownloads urlSource = do
-                   '[JSONError , DownloadFailed , FileDoesNotExistError]
+  lift $ $(logDebug) [i|Receiving download info from: #{urlSource}|]
-                   m
-                   GHCupInfo
-getDownloadsF urlSource = do
   case urlSource of
-    GHCupURL -> liftE getBase
+    GHCupURL -> do
+      bs <- reThrowAll DownloadFailed $ smartDl ghcupURL
+      lE' JSONDecodeError $ eitherDecode' bs
     (OwnSource url) -> do
       bs <- reThrowAll DownloadFailed $ downloadBS url
-      lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)
+      lE' JSONDecodeError $ eitherDecode' bs
-    (OwnSpec av) -> pure av
+    (OwnSpec av) -> pure $ av
-    (AddSource (Left ext)) -> do
-      base <- liftE getBase
-      pure (mergeGhcupInfo base ext)
-    (AddSource (Right uri)) -> do
-      base <- liftE getBase
-      bsExt <- reThrowAll DownloadFailed $ downloadBS uri
-      ext <- lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bsExt)
-      pure (mergeGhcupInfo base ext)
 
-    where
+ where
-
-  mergeGhcupInfo :: GHCupInfo -- ^ base to merge with
-                 -> GHCupInfo -- ^ extension overwriting the base
-                 -> GHCupInfo
-  mergeGhcupInfo (GHCupInfo tr base) (GHCupInfo _ ext) =
-    let new = M.mapWithKey (\k a -> case M.lookup k ext of
-                                        Just a' -> M.union a' a
-                                        Nothing -> a
-                           ) base
-    in GHCupInfo tr new
-
-
-readFromCache :: (MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
-              => Excepts '[JSONError, FileDoesNotExistError] m GHCupInfo
-readFromCache = do
-  AppState {dirs = Dirs {..}} <- lift ask
-  lift $ $(logWarn)
-    [i|Could not get download info, trying cached version (this may not be recent!)|]
-  let path = view pathL' ghcupURL
-  yaml_file <- (cacheDir </>) <$> urlBaseName path
-  bs        <-
-    handleIO' NoSuchThing
-              (\_ -> throwE $ FileDoesNotExistError (toFilePath yaml_file))
-    $ liftIO
-    $ readFile yaml_file
-  lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)
-
-
-getBase :: (MonadFail m, MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
-        => Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
-getBase =
-  handleIO (\_ -> readFromCache)
-  $ catchE @_ @'[JSONError, FileDoesNotExistError]
-      (\(DownloadFailed _) -> readFromCache)
-  (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.
@@ -186,12 +116,7 @@ getBase =
   --
   -- Always save the local file with the mod time of the remote file.
   smartDl :: forall m1
-           . ( MonadCatch m1
+           . (MonadCatch m1, MonadIO m1, MonadFail m1, MonadLogger m1)
-             , MonadIO m1
-             , MonadFail m1
-             , MonadLogger m1
-             , MonadReader AppState m1
-             )
           => URI
           -> Excepts
                '[ FileDoesNotExistError
@@ -205,16 +130,16 @@ getBase =
                m1
                L.ByteString
   smartDl uri' = do
-    AppState {dirs = Dirs {..}} <- lift ask
     let path = view pathL' uri'
+    cacheDir  <- liftIO $ ghcupCacheDir
     json_file <- (cacheDir </>) <$> urlBaseName path
     e         <- liftIO $ doesFileExist json_file
     if e
       then do
         accessTime <-
           PF.accessTimeHiRes
-            <$> liftIO (PF.getFileStatus (toFilePath json_file))
+            <$> (liftIO $ PF.getFileStatus (toFilePath json_file))
-        currentTime <- liftIO getPOSIXTime
+        currentTime <- liftIO $ getPOSIXTime
 
         -- access time won't work on most linuxes, but we can try regardless
         if (currentTime - accessTime) > 300
@@ -223,38 +148,31 @@ getBase =
               Just modTime -> do
                 fileMod <- liftIO $ getModificationTime json_file
                 if modTime > fileMod
-                  then dlWithMod modTime json_file
+                  then do
+                    bs <- liftE $ downloadBS uri'
+                    liftIO $ writeFileWithModTime modTime json_file bs
+                    pure bs
                   else liftIO $ readFile json_file
               Nothing -> do
                 lift $ $(logDebug) [i|Unable to get/parse Last-Modified header|]
-                dlWithoutMod json_file
+                liftIO $ deleteFile json_file
+                liftE $ downloadBS uri'
           else -- access in less than 5 minutes, re-use file
                liftIO $ readFile json_file
       else do
-        liftIO $ createDirRecursive' cacheDir
+        liftIO $ createDirIfMissing newDirPerms cacheDir
         getModTime >>= \case
-          Just modTime -> dlWithMod modTime json_file
+          Just modTime -> do
+            bs <- liftE $ downloadBS uri'
+            liftIO $ writeFileWithModTime modTime json_file bs
+            pure bs
           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|]
-            dlWithoutMod json_file
+            liftE $ downloadBS uri'
 
    where
-    dlWithMod modTime json_file = do
-      bs <- liftE $ downloadBS uri'
-      liftIO $ writeFileWithModTime modTime json_file bs
-      pure bs
-    dlWithoutMod json_file = do
-      bs <- liftE $ downloadBS uri'
-      liftIO $ hideError doesNotExistErrorType $ deleteFile json_file
-      liftIO $ writeFileL json_file (Just newFilePerms) bs
-      liftIO $ setModificationTime json_file (fromIntegral @Int 0)
-      pure bs
-
-
     getModTime = do
-#if !defined(INTERNAL_DOWNLOADER)
+#if defined(CURL)
       pure Nothing
 #else
       headers <-
@@ -294,11 +212,7 @@ getDownloadInfo :: Tool
 getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
   (Left NoDownload)
   Right
-  (case p of
+  (with_distro <|> without_distro_ver <|> without_distro)
-    -- 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
@@ -306,18 +220,7 @@ getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
   without_distro     = distro_preview (set _Linux UnknownLinux) (const Nothing)
 
   distro_preview f g =
-    let platformVersionSpec =
+    preview (ix t % ix v % viArch % ix a % ix (f p) % ix (g mv)) dls
-          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
@@ -328,7 +231,7 @@ getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
 --
 -- The file must not exist.
 download :: ( MonadMask m
-            , MonadReader AppState m
+            , MonadReader Settings m
             , MonadThrow m
             , MonadLogger m
             , MonadIO m
@@ -347,7 +250,7 @@ download dli dest mfn
   scheme = view (dlUri % uriSchemeL' % schemeBSL') dli
   cp     = do
     -- destination dir must exist
-    liftIO $ createDirRecursive' dest
+    liftIO $ hideError AlreadyExists $ createDirRecursive newDirPerms dest
     destFile <- getDestFile
     fromFile <- parseAbs path
     liftIO $ copyFile fromFile destFile Strict
@@ -357,7 +260,7 @@ download dli dest mfn
     lift $ $(logInfo) [i|downloading: #{uri'}|]
 
     -- destination dir must exist
-    liftIO $ createDirRecursive' dest
+    liftIO $ hideError AlreadyExists $ createDirRecursive newDirPerms dest
     destFile <- getDestFile
 
     -- download
@@ -365,22 +268,15 @@ download dli dest mfn
          (liftIO $ hideError doesNotExistErrorType $ deleteFile destFile)
      $ catchAllE @_ @'[ProcessError, DownloadFailed, UnsupportedScheme]
           (\e ->
-            liftIO (hideError doesNotExistErrorType $ deleteFile destFile)
+            (liftIO $ hideError doesNotExistErrorType $ deleteFile destFile)
               >> (throwE . DownloadFailed $ e)
           ) $ do
-              lift getDownloader >>= \case
+#if defined(CURL)
-                Curl -> do
+              liftE $ lEM @_ @'[ProcessError] $ liftIO $ exec "curl" True
-                  o' <- liftIO getCurlOpts
+                ["-fL", "-o", toFilePath destFile , serializeURIRef' $ view dlUri dli] Nothing Nothing
-                  liftE $ lEM @_ @'[ProcessError] $ liftIO $ exec "curl" True
+#else
-                    (o' ++ ["-fL", "-o", toFilePath destFile, serializeURIRef' $ view dlUri dli]) Nothing Nothing
+              (https, host, fullPath, port) <- liftE $ uriToQuadruple (view dlUri dli)
-                Wget -> do
+              liftE $ downloadToFile https host fullPath port destFile
-                  o' <- liftIO getWgetOpts
-                  liftE $ lEM @_ @'[ProcessError] $ liftIO $ exec "wget" True
-                    (o' ++ ["-O", toFilePath destFile , 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
@@ -400,7 +296,7 @@ downloadCached :: ( MonadMask m
                   , MonadThrow m
                   , MonadLogger m
                   , MonadIO m
-                  , MonadReader AppState m
+                  , MonadReader Settings m
                   )
                => DownloadInfo
                -> Maybe (Path Rel)  -- ^ optional filename
@@ -409,15 +305,15 @@ downloadCached dli mfn = do
   cache <- lift getCache
   case cache of
     True -> do
-      AppState {dirs = Dirs {..}} <- lift ask
+      cachedir <- liftIO $ ghcupCacheDir
       fn       <- maybe (urlBaseName $ view (dlUri % pathL') dli) pure mfn
-      let cachfile = cacheDir </> fn
+      let cachfile = cachedir </> fn
       fileExists <- liftIO $ doesFileExist cachfile
       if
         | fileExists -> do
           liftE $ checkDigest dli cachfile
-          pure cachfile
+          pure $ cachfile
-        | otherwise -> liftE $ download dli cacheDir mfn
+        | otherwise -> liftE $ download dli cachedir mfn
     False -> do
       tmp <- lift withGHCupTmpDir
       liftE $ download dli tmp mfn
@@ -433,7 +329,7 @@ downloadCached dli mfn = do
 
 
 -- | This is used for downloading the JSON.
-downloadBS :: (MonadReader AppState m, MonadCatch m, MonadIO m, MonadLogger m)
+downloadBS :: (MonadCatch m, MonadIO m)
            => URI
            -> Excepts
                 '[ FileDoesNotExistError
@@ -453,49 +349,34 @@ downloadBS uri'
   = dl False
   | scheme == "file"
   = liftIOException doesNotExistErrorType (FileDoesNotExistError path)
-    (liftIO $ RD.readFile path)
+    $ (liftIO $ RD.readFile path)
   | otherwise
   = throwE UnsupportedScheme
 
  where
   scheme = view (uriSchemeL' % schemeBSL') uri'
   path   = view pathL' uri'
-#if defined(INTERNAL_DOWNLOADER)
+#if defined(CURL)
-  dl https = do
-#else
   dl _ = do
-#endif
+    let exe = [rel|curl|]
-    lift $ $(logDebug) [i|downloading: #{serializeURIRef' uri'}|]
+        args = ["-sSfL", serializeURIRef' uri']
-    lift getDownloader >>= \case
+    liftIO (executeOut exe args Nothing) >>= \case
-      Curl -> do
+      CapturedProcess ExitSuccess stdout _ -> do
-        o' <- liftIO getCurlOpts
+        pure $ L.fromStrict stdout
-        let exe = [rel|curl|]
+      CapturedProcess (ExitFailure i') _ _ -> throwE $ NonZeroExit i' (toFilePath exe) args
-            args = o' ++ ["-sSfL", serializeURIRef' uri']
+#else
-        liftIO (executeOut exe args Nothing) >>= \case
+  dl https = do
-          CapturedProcess ExitSuccess stdout _ -> do
+    (_, host', fullPath', port') <- liftE $ uriToQuadruple uri'
-            pure $ L.fromStrict stdout
+    liftE $ downloadBS' https host' fullPath' port'
-          CapturedProcess (ExitFailure i') _ _ -> throwE $ NonZeroExit i' (toFilePath exe) args
-      Wget -> do
-        o' <- liftIO getWgetOpts
-        let exe = [rel|wget|]
-            args = o' ++ ["-qO-", 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
-#if defined(INTERNAL_DOWNLOADER)
-      Internal -> do
-        (_, host', fullPath', port') <- liftE $ uriToQuadruple uri'
-        liftE $ downloadBS' https host' fullPath' port'
 #endif
 
 
-checkDigest :: (MonadIO m, MonadThrow m, MonadLogger m, MonadReader AppState m)
+checkDigest :: (MonadIO m, MonadThrow m, MonadLogger m, MonadReader Settings m)
             => DownloadInfo
             -> Path Abs
             -> Excepts '[DigestError] m ()
 checkDigest dli file = do
-  verify <- lift ask <&> (not . noVerify . settings)
+  verify <- lift ask <&> (not . noVerify)
   when verify $ do
     p' <- toFilePath <$> basename file
     lift $ $(logInfo) [i|verifying digest of: #{p'}|]
@@ -504,19 +385,3 @@ checkDigest dli file = do
     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 [ByteString]
-getCurlOpts =
-  getEnv "GHCUP_CURL_OPTS" >>= \case
-    Just r  -> pure $ BS.split _space r
-    Nothing -> pure []
-
-
--- | Get additional wget args from env. This is an undocumented option.
-getWgetOpts :: IO [ByteString]
-getWgetOpts =
-  getEnv "GHCUP_WGET_OPTS" >>= \case
-    Just r  -> pure $ BS.split _space r
-    Nothing -> pure []
-

lib/GHCup/Download/IOStreams.hs

@@ -1,6 +1,10 @@
 {-# LANGUAGE DataKinds             #-}
+{-# LANGUAGE DeriveGeneric         #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE TemplateHaskell       #-}
+{-# LANGUAGE TypeApplications      #-}
 {-# LANGUAGE TypeFamilies          #-}
 
 
@@ -68,7 +72,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)
@@ -128,7 +132,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
         )
@@ -147,7 +151,7 @@ downloadInternal = go (5 :: Int)
             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
@@ -220,9 +224,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
         )
@@ -239,7 +243,7 @@ withConnection' :: Bool
                 -> Maybe Int
                 -> (Connection -> IO a)
                 -> IO a
-withConnection' https host port = bracket acquire closeConnection
+withConnection' https host port action = bracket acquire closeConnection action
 
  where
   acquire = case https of

lib/GHCup/Download/Utils.hs

@@ -1,6 +1,10 @@
 {-# LANGUAGE DataKinds             #-}
+{-# LANGUAGE DeriveGeneric         #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE TemplateHaskell       #-}
+{-# LANGUAGE TypeApplications      #-}
 {-# LANGUAGE TypeFamilies          #-}
 
 
@@ -51,7 +55,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,40 +1,18 @@
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# LANGUAGE CPP               #-}
-{-# LANGUAGE DataKinds               #-}
 {-# LANGUAGE ExistentialQuantification #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE QuasiQuotes           #-}
+{-# LANGUAGE DataKinds #-}
-{-# 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 : POSIX
--}
 module GHCup.Errors where
 
 import           GHCup.Types
-import           GHCup.Utils.Prelude
 
-#if !defined(TAR)
-import           Codec.Archive
-#endif
 import           Control.Exception.Safe
 import           Data.ByteString                ( ByteString )
-import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
-import           HPath
 import           Haskus.Utils.Variant
-import           Text.PrettyPrint
+import           HPath
-import           Text.PrettyPrint.HughesPJClass
-import           URI.ByteString
 
 
 
@@ -48,203 +26,94 @@ import           URI.ByteString
 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
   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 "#{decUTF8Safe 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 GHCTargetVersion
+data NotInstalled = NotInstalled Tool Text
   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)
   deriving Show
 
-instance Pretty NotFoundInPATH where
-  pPrint (NotFoundInPATH exe) =
-    text [i|The exe "#{decUTF8Safe . toFilePath $ 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
   deriving Show
 
-instance Pretty FileDoesNotExistError where
-  pPrint (FileDoesNotExistError file) =
-    text [i|File "#{decUTF8Safe 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 x xs . (Show x, Show (V xs), Pretty x, Pretty (V xs)) => DownloadFailed (V (x ': xs))
+data DownloadFailed = forall es . Show (V es) => DownloadFailed (V es)
-
-instance Pretty DownloadFailed where
-  pPrint (DownloadFailed reason) =
-    text "Download failed:" <+> pPrint reason
 
 deriving instance Show DownloadFailed
 
@@ -252,20 +121,12 @@ deriving instance Show DownloadFailed
 -- | A build failed.
 data BuildFailed = forall es . Show (V es) => BuildFailed (Path Abs) (V es)
 
-instance Pretty BuildFailed where
-  pPrint (BuildFailed path reason) =
-    text [i|BuildFailed failed in dir "#{decUTF8Safe . toFilePath $ path}": #{reason}|]
-
 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
 
 
@@ -278,65 +139,4 @@ 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"
-#endif

lib/GHCup/Platform.hs

@@ -6,21 +6,13 @@
 {-# 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 : POSIX
--}
 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
@@ -44,7 +36,6 @@ import           Prelude                 hiding ( abs
                                                 , writeFile
                                                 )
 import           System.Info
-import           System.OsRelease
 import           Text.Regex.Posix
 
 import qualified Data.Text                     as T
@@ -57,7 +48,10 @@ import qualified Data.Text                     as T
 -- | Get the full platform request, consisting of architecture, distro, ...
 platformRequest :: (MonadLogger m, MonadCatch m, MonadIO m)
                 => Excepts
-                     '[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound]
+                     '[ NoCompatiblePlatform
+                      , NoCompatibleArch
+                      , DistroNotFound
+                      ]
                      m
                      PlatformRequest
 platformRequest = do
@@ -68,21 +62,15 @@ platformRequest = do
 
 getArchitecture :: Either NoCompatibleArch Architecture
 getArchitecture = case arch of
-  "x86_64"      -> Right A_64
+  "x86_64" -> Right A_64
-  "i386"        -> Right A_32
+  "i386"   -> Right A_32
-  "powerpc"     -> Right A_PowerPC
+  what     -> Left (NoCompatibleArch what)
-  "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)
             => Excepts
-                 '[NoCompatiblePlatform, DistroNotFound]
+                 '[NoCompatiblePlatform , DistroNotFound]
                  m
                  PlatformResult
 getPlatform = do
@@ -92,16 +80,16 @@ 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
           . decUTF8Safe
-        <$> getDarwinVersion
+          )
+          <$> getDarwinVersion
       pure $ PlatformResult { _platform = Darwin, _distroVersion = ver }
     "freebsd" -> do
       ver <-
-        either (const Nothing) Just . versioning . decUTF8Safe
+        (either (const Nothing) Just . versioning . decUTF8Safe)
           <$> getFreeBSDVersion
       pure $ PlatformResult { _platform = FreeBSD, _distroVersion = ver }
     what -> throwE $ NoCompatiblePlatform what
@@ -123,6 +111,7 @@ getLinuxDistro = do
   (name, ver) <- handleIO (\_ -> throwE DistroNotFound) $ liftIO $ asum
     [ try_os_release
     , try_lsb_release_cmd
+    , try_lsb_release
     , try_redhat_release
     , try_debian_version
     ]
@@ -147,6 +136,10 @@ 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
@@ -156,9 +149,9 @@ getLinuxDistro = do
 
   try_os_release :: IO (Text, Maybe Text)
   try_os_release = do
-    Just OsRelease{ name = name, version_id = version_id } <-
+    (Just name) <- getAssignmentValueFor os_release "NAME"
-      fmap osRelease <$> parseOsRelease
+    ver         <- getAssignmentValueFor os_release "VERSION_ID"
-    pure (T.pack name, fmap T.pack version_id)
+    pure (T.pack name, fmap T.pack ver)
 
   try_lsb_release_cmd :: IO (Text, Maybe Text)
   try_lsb_release_cmd = do
@@ -167,13 +160,19 @@ getLinuxDistro = do
     ver      <- fmap _stdOut $ executeOut lsb_release_cmd ["-sr"] Nothing
     pure (decUTF8Safe name, Just $ decUTF8Safe 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)
+
   try_redhat_release :: IO (Text, Maybe Text)
   try_redhat_release = do
     t <- fmap decUTF8Safe' $ 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

lib/GHCup/Requirements.hs

@@ -1,23 +1,12 @@
 {-# LANGUAGE OverloadedStrings #-}
 
-{-|
-Module      : GHCup.Requirements
-Description : Requirements utilities
-Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
-Maintainer  : hasufell@hasufell.de
-Stability   : experimental
-Portability : POSIX
--}
 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
@@ -25,7 +14,6 @@ import           Prelude                 hiding ( abs
                                                 , writeFile
                                                 )
 
-import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 
 
@@ -36,32 +24,22 @@ getCommonRequirements :: PlatformResult
                       -> ToolRequirements
                       -> Maybe Requirements
 getCommonRequirements pr tr =
-  with_distro <|> without_distro_ver <|> without_distro
+  preview (ix GHC % ix Nothing % ix (_platform pr) % ix (_distroVersion pr)) tr
- where
+    <|> preview (ix GHC % ix Nothing % ix (_platform pr) % ix Nothing) tr
-  with_distro        = distro_preview _platform _distroVersion
+    <|> preview
-  without_distro_ver = distro_preview _platform (const Nothing)
+          ( ix GHC
-  without_distro     = distro_preview (set _Linux UnknownLinux . _platform) (const Nothing)
+          % ix Nothing
-
+          % ix (set _Linux UnknownLinux $ _platform pr)
-  distro_preview f g =
+          % ix Nothing
-    let platformVersionSpec =
+          )
-          preview (ix GHC % ix Nothing % ix (f pr)) tr
+          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  Please install the following distro packages: "
+          "\n  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,34 +1,15 @@
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# LANGUAGE CPP               #-}
 {-# LANGUAGE DeriveGeneric     #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes           #-}
 
-{-|
-Module      : GHCup.Types
-Description : GHCup types
-Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
-Maintainer  : hasufell@hasufell.de
-Stability   : experimental
-Portability : POSIX
--}
 module GHCup.Types where
 
 import           Data.Map.Strict                ( Map )
-import           Data.List.NonEmpty             ( NonEmpty (..) )
-import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           HPath
-import           Text.PrettyPrint.HughesPJClass (Pretty, pPrint, text)
 import           URI.ByteString
 
-import qualified Data.Text                     as T
-import qualified Data.Text.Encoding            as E
-import qualified Data.Text.Encoding.Error      as E
 import qualified GHC.Generics                  as GHC
-import qualified Graphics.Vty                  as Vty
 
 
 
@@ -53,7 +34,7 @@ data GHCupInfo = GHCupInfo
 type ToolRequirements = Map Tool ToolReqVersionSpec
 type ToolReqVersionSpec = Map (Maybe Version) PlatformReqSpec
 type PlatformReqSpec = Map Platform PlatformReqVersionSpec
-type PlatformReqVersionSpec = Map (Maybe VersionRange) Requirements
+type PlatformReqVersionSpec = Map (Maybe Versioning) Requirements
 
 
 data Requirements = Requirements
@@ -77,79 +58,39 @@ type GHCupDownloads = Map Tool ToolVersionSpec
 type ToolVersionSpec = Map Version VersionInfo
 type ArchitectureSpec = Map Architecture PlatformSpec
 type PlatformSpec = Map Platform PlatformVersionSpec
-type PlatformVersionSpec = Map (Maybe VersionRange) DownloadInfo
+type PlatformVersionSpec = Map (Maybe Versioning) DownloadInfo
 
 
 -- | An installable tool.
 data Tool = GHC
           | Cabal
           | GHCup
-          | HLS
+  deriving (Eq, GHC.Generic, Ord, Show)
-  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
+  { _viTags      :: [Tag]              -- ^ version specific tag
-  , _viChangeLog   :: Maybe URI
+  , _viChangeLog :: Maybe URI
-  , _viSourceDL    :: Maybe DownloadInfo -- ^ source tarball
+  , _viSourceDL  :: Maybe DownloadInfo -- ^ source tarball
-  , _viArch        :: ArchitectureSpec   -- ^ descend for binary downloads per arch
+  , _viArch      :: ArchitectureSpec   -- ^ descend for binary downloads per arch
-  -- informative messages
-  , _viPostInstall :: Maybe Text
-  , _viPostRemove  :: Maybe Text
-  , _viPreCompile  :: Maybe Text
   }
-  deriving (Eq, GHC.Generic, Show)
+  deriving (Eq, Show)
 
 
 -- | A tag. These are currently attached to a version of a tool.
 data Tag = Latest
          | Recommended
-         | 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
+         deriving (Ord, Eq, 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
@@ -158,14 +99,6 @@ data Platform = Linux LinuxDistro
               | FreeBSD
   deriving (Eq, GHC.Generic, Ord, Show)
 
-platformToString :: Platform -> String
-platformToString (Linux distro) = "linux-" ++ distroToString distro
-platformToString Darwin = "darwin"
-platformToString FreeBSD = "freebsd"
-
-instance Pretty Platform where
-  pPrint = text . platformToString
-
 data LinuxDistro = Debian
                  | Ubuntu
                  | Mint
@@ -182,31 +115,15 @@ 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 TarDir
+  , _dlSubdir :: Maybe (Path Rel)
   , _dlHash   :: Text
   }
-  deriving (Eq, Ord, GHC.Generic, Show)
+  deriving (Eq, Show)
 
 
 
@@ -216,110 +133,26 @@ data DownloadInfo = DownloadInfo
     --------------
 
 
--- | How to descend into a tar archive.
-data TarDir = RealDir (Path Rel)
-            | 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 [i|#{E.decodeUtf8With E.lenientDecode . toFilePath $ path}|]
-  pPrint (RegexDir regex) = text regex
-
-
 -- | Where to fetch GHCupDownloads from.
 data URLSource = GHCupURL
                | OwnSource URI
                | OwnSpec GHCupInfo
-               | AddSource (Either GHCupInfo URI) -- ^ merge with GHCupURL
+               deriving Show
-               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 Vty.Key
-  , kDown      :: Maybe Vty.Key
-  , kQuit      :: Maybe Vty.Key
-  , kInstall   :: Maybe Vty.Key
-  , kUninstall :: Maybe Vty.Key
-  , kSet       :: Maybe Vty.Key
-  , kChangelog :: Maybe Vty.Key
-  , kShowAll   :: Maybe Vty.Key
-  }
-  deriving (Show, GHC.Generic)
-
-data KeyBindings = KeyBindings
-  { bUp        :: Vty.Key
-  , bDown      :: Vty.Key
-  , bQuit      :: Vty.Key
-  , bInstall   :: Vty.Key
-  , bUninstall :: Vty.Key
-  , bSet       :: Vty.Key
-  , bChangelog :: Vty.Key
-  , bShowAll   :: Vty.Key
-  }
-  deriving (Show, GHC.Generic)
-
-defaultKeyBindings :: KeyBindings
-defaultKeyBindings = KeyBindings
-  { bUp = Vty.KUp
-  , bDown = Vty.KDown
-  , bQuit = Vty.KChar 'q'
-  , bInstall = Vty.KChar 'i'
-  , bUninstall = Vty.KChar 'u'
-  , bSet = Vty.KChar 's'
-  , bChangelog = Vty.KChar 'c'
-  , bShowAll = Vty.KChar 'a'
-  }
-
-data AppState = AppState
-  { settings :: Settings
-  , dirs :: Dirs
-  , keyBindings :: KeyBindings
-  } deriving (Show)
-
 data Settings = Settings
-  { cache      :: Bool
+  { cache    :: Bool
-  , noVerify   :: Bool
+  , noVerify :: Bool
-  , keepDirs   :: KeepDirs
+  , keepDirs :: KeepDirs
-  , downloader :: Downloader
-  , verbose    :: Bool
-  , urlSource  :: URLSource
-  }
-  deriving (Show, GHC.Generic)
-
-data Dirs = Dirs
-  { baseDir  :: Path Abs
-  , binDir   :: Path Abs
-  , cacheDir :: Path Abs
-  , logsDir  :: Path Abs
-  , confDir  :: Path Abs
   }
   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
@@ -344,15 +177,6 @@ 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
@@ -360,16 +184,6 @@ data PlatformRequest = PlatformRequest
   }
   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.
@@ -383,33 +197,9 @@ data GHCTargetVersion = GHCTargetVersion
 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
+prettyTVer :: GHCTargetVersion -> Text
-  pPrint = text . T.unpack . tVerToText
+prettyTVer (GHCTargetVersion (Just t) v') = t <> "-" <> prettyVer v'
+prettyTVer (GHCTargetVersion Nothing  v') = prettyVer v'
 
-
--- | 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

lib/GHCup/Types/JSON.hs

@@ -10,46 +10,27 @@
 {-# 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 : POSIX
--}
 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.Void
 import           Data.Word8
 import           HPath
 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 Graphics.Vty                  as Vty
-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 } ''MChunk
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Platform
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''SemVer
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
@@ -59,18 +40,10 @@ deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Versio
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''DownloadInfo
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GHCupInfo
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Requirements
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''KeepDirs
-deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Downloader
-deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''URLSource
-deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "u-") . T.pack . kebab $ str' } ''UserSettings
-deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "k-") . T.pack . kebab $ str' } ''UserKeyBindings
-deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''Vty.Key
 
 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)
 
@@ -78,8 +51,6 @@ 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
@@ -117,10 +88,10 @@ instance ToJSONKey (Maybe Versioning) where
 
 instance FromJSONKey (Maybe Versioning) where
   fromJSONKey = FromJSONKeyTextParser $ \t ->
-    if t == T.pack "unknown_versioning" then pure Nothing else just t
+    if t == T.pack "unknown_versioning" then pure Nothing else pure $ just t
    where
     just t = case versioning t of
-      Right x -> pure $ Just x
+      Right x -> pure x
       Left  e -> fail $ "Failure in (Maybe Versioning) (FromJSONKey)" <> show e
 
 instance ToJSONKey Platform where
@@ -148,7 +119,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
@@ -163,10 +134,10 @@ instance ToJSONKey (Maybe Version) where
 
 instance FromJSONKey (Maybe Version) where
   fromJSONKey = FromJSONKeyTextParser $ \t ->
-    if t == T.pack "unknown_version" then pure Nothing else just t
+    if t == T.pack "unknown_version" then pure Nothing else pure $ just t
    where
     just t = case version t of
-      Right x -> pure $ Just x
+      Right x -> pure x
       Left  e -> fail $ "Failure in (Maybe Version) (FromJSONKey)" <> show e
 
 instance ToJSON Version where
@@ -211,114 +182,3 @@ instance FromJSON (Path Rel) where
     case parseRel d of
       Right x -> pure x
       Left  e -> fail $ "Failure in HPath Rel (FromJSON)" <> show e
-
-
-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

lib/GHCup/Types/Optics.hs

@@ -1,14 +1,5 @@
 {-# 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 : POSIX
--}
 module GHCup.Types.Optics where
 
 import           GHCup.Types

lib/GHCup/Utils.hs

@@ -4,21 +4,9 @@
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE TemplateHaskell       #-}
-{-# LANGUAGE TypeApplications      #-}
 {-# LANGUAGE ViewPatterns          #-}
 
-{-|
-Module      : GHCup.Utils
-Description : GHCup domain specific utilities
-Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
-Maintainer  : hasufell@hasufell.de
-Stability   : experimental
-Portability : POSIX
 
-This module contains GHCup helpers specific to
-installation and introspection of files/versions etc.
--}
 module GHCup.Utils
   ( module GHCup.Utils.Dirs
   , module GHCup.Utils
@@ -36,9 +24,6 @@ import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
 import           GHCup.Utils.String.QQ
 
-#if !defined(TAR)
-import           Codec.Archive           hiding ( Directory )
-#endif
 import           Control.Applicative
 import           Control.Exception.Safe
 import           Control.Monad
@@ -49,10 +34,7 @@ import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Data.ByteString                ( ByteString )
 import           Data.Either
-import           Data.Foldable
 import           Data.List
-import           Data.List.NonEmpty             ( NonEmpty( (:|) ))
-import           Data.List.Split
 import           Data.Maybe
 import           Data.String.Interpolate
 import           Data.Text                      ( Text )
@@ -60,7 +42,7 @@ import           Data.Versions
 import           Data.Word8
 import           GHC.IO.Exception
 import           HPath
-import           HPath.IO                hiding ( hideError )
+import           HPath.IO
 import           Haskus.Utils.Variant.Excepts
 import           Optics
 import           Prelude                 hiding ( abs
@@ -76,18 +58,12 @@ import           System.Posix.Files.ByteString  ( readSymbolicLink )
 import           Text.Regex.Posix
 import           URI.ByteString
 
-#if defined(TAR)
 import qualified Codec.Archive.Tar             as Tar
-#endif
 import qualified Codec.Compression.BZip        as BZip
 import qualified Codec.Compression.GZip        as GZip
 import qualified Codec.Compression.Lzma        as Lzma
 import qualified Data.ByteString               as B
-import qualified Data.ByteString.Lazy          as BL
 import qualified Data.Map.Strict               as Map
-#if !defined(TAR)
-import qualified Data.Text                     as T
-#endif
 import qualified Data.Text.Encoding            as E
 import qualified Text.Megaparsec               as MP
 
@@ -101,82 +77,72 @@ import qualified Text.Megaparsec               as MP
 
 
 -- | The symlink destination of a ghc tool.
-ghcLinkDestination :: (MonadReader AppState m, MonadThrow m, MonadIO m)
+ghcLinkDestination :: ByteString -- ^ the tool, such as 'ghc', 'haddock' etc.
-                   => ByteString -- ^ the tool, such as 'ghc', 'haddock' etc.
                    -> GHCTargetVersion
-                   -> m ByteString
+                   -> ByteString
-ghcLinkDestination tool ver = do
+ghcLinkDestination tool ver =
-  AppState { dirs = Dirs {..} } <- ask
+  "../ghc/" <> E.encodeUtf8 (prettyTVer ver) <> "/bin/" <> tool
-  t <- parseRel tool
-  ghcd <- ghcupGHCDir ver
-  pure (relativeSymlink binDir (ghcd </> [rel|bin|] </> t))
 
 
--- | Removes the minor GHC symlinks, e.g. ghc-8.6.5.
+-- e.g. ghc-8.6.5
-rmMinorSymlinks :: ( MonadReader AppState m
+rmMinorSymlinks :: (MonadIO m, MonadLogger m) => GHCTargetVersion -> m ()
-                   , MonadIO m
+rmMinorSymlinks GHCTargetVersion {..} = do
-                   , MonadLogger m
+  bindir <- liftIO $ ghcupBinDir
-                   , MonadThrow m
+
-                   , MonadFail m
+  files  <- liftIO $ findFiles'
-                   , MonadReader AppState m
+    bindir
-                   )
+    (  maybe mempty (\x -> MP.chunk (x <> "-")) _tvTarget
-                => GHCTargetVersion
+    *> parseUntil1 (MP.chunk $ prettyVer _tvVersion)
-                -> Excepts '[NotInstalled] m ()
+    *> (MP.chunk $ prettyVer _tvVersion)
-rmMinorSymlinks tv@GHCTargetVersion{..} = do
+    *> MP.eof
-  AppState { dirs = Dirs {..} } <- lift ask
+    )
 
-  files                         <- liftE $ ghcToolFiles tv
   forM_ files $ \f -> do
-    f_xyz <- liftIO $ parseRel (toFilePath f <> B.singleton _hyphen <> verToBS _tvVersion)
+    let fullF = (bindir </> f)
-    let fullF = binDir </> f_xyz
+    $(logDebug) [i|rm -f #{toFilePath fullF}|]
-    lift $ $(logDebug) [i|rm -f #{toFilePath fullF}|]
     liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
 
 
--- | Removes the set ghc version for the given target, if any.
+-- Removes the set ghc version for the given target, if any.
-rmPlain :: ( MonadReader AppState m
+rmPlain :: (MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
-           , MonadLogger m
+  => Maybe Text -- ^ target
-           , MonadThrow m
-           , MonadFail m
-           , MonadIO m
-           )
-        => Maybe Text -- ^ target
         -> Excepts '[NotInstalled] m ()
 rmPlain target = do
-  AppState { dirs = Dirs {..} } <- lift ask
+  mtv <- ghcSet target
-  mtv                           <- lift $ ghcSet target
   forM_ mtv $ \tv -> do
-    files <- liftE $ ghcToolFiles tv
+    files  <- liftE $ ghcToolFiles tv
+    bindir <- liftIO $ ghcupBinDir
     forM_ files $ \f -> do
-      let fullF = binDir </> f
+      let fullF = (bindir </> f)
       lift $ $(logDebug) [i|rm -f #{toFilePath fullF}|]
       liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
     -- old ghcup
-    let hdc_file = binDir </> [rel|haddock-ghc|]
+    let hdc_file = (bindir </> [rel|haddock-ghc|])
     lift $ $(logDebug) [i|rm -f #{toFilePath hdc_file}|]
     liftIO $ hideError doesNotExistErrorType $ deleteFile hdc_file
 
 
--- | Remove the major GHC symlink, e.g. ghc-8.6.
+-- e.g. ghc-8.6
-rmMajorSymlinks :: ( MonadReader AppState m
+rmMajorSymlinks :: (MonadThrow m, MonadLogger m, MonadIO m)
-                   , MonadIO m
-                   , MonadLogger m
-                   , MonadThrow m
-                   , MonadFail m
-                   , MonadReader AppState m
-                   )
                 => GHCTargetVersion
-                -> Excepts '[NotInstalled] m ()
+                -> m ()
-rmMajorSymlinks tv@GHCTargetVersion{..} = do
+rmMajorSymlinks GHCTargetVersion {..} = do
-  AppState { dirs = Dirs {..} } <- lift ask
   (mj, mi) <- getMajorMinorV _tvVersion
   let v' = intToText mj <> "." <> intToText mi
 
-  files                         <- liftE $ ghcToolFiles tv
+  bindir <- liftIO ghcupBinDir
+
+  files  <- liftIO $ findFiles'
+    bindir
+    (  maybe mempty (\x -> MP.chunk (x <> "-")) _tvTarget
+    *> parseUntil1 (MP.chunk v')
+    *> MP.chunk v'
+    *> MP.eof
+    )
+
   forM_ files $ \f -> do
-    f_xyz <- liftIO $ parseRel (toFilePath f <> B.singleton _hyphen <> E.encodeUtf8 v')
+    let fullF = (bindir </> f)
-    let fullF = binDir </> f_xyz
+    $(logDebug) [i|rm -f #{toFilePath fullF}|]
-    lift $ $(logDebug) [i|rm -f #{toFilePath fullF}|]
     liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
 
 
@@ -187,296 +153,75 @@ rmMajorSymlinks tv@GHCTargetVersion{..} = do
     -----------------------------------
 
 
--- | Whethe the given GHC versin is installed.
+ghcInstalled :: GHCTargetVersion -> IO Bool
-ghcInstalled :: (MonadIO m, MonadReader AppState m, MonadThrow m) => GHCTargetVersion -> m Bool
 ghcInstalled ver = do
   ghcdir <- ghcupGHCDir ver
-  liftIO $ doesDirectoryExist ghcdir
+  doesDirectoryExist ghcdir
 
 
--- | Whether the given GHC version is installed from source.
+ghcSrcInstalled :: GHCTargetVersion -> IO Bool
-ghcSrcInstalled :: (MonadIO m, MonadReader AppState m, MonadThrow m) => GHCTargetVersion -> m Bool
 ghcSrcInstalled ver = do
   ghcdir <- ghcupGHCDir ver
-  liftIO $ doesFileExist (ghcdir </> ghcUpSrcBuiltFile)
+  doesFileExist (ghcdir </> ghcUpSrcBuiltFile)
 
 
--- | Whether the given GHC version is set as the current.
+ghcSet :: (MonadThrow m, MonadIO m)
-ghcSet :: (MonadReader AppState m, MonadThrow m, MonadIO m)
        => Maybe Text   -- ^ the target of the GHC version, if any
                        --  (e.g. armv7-unknown-linux-gnueabihf)
        -> m (Maybe GHCTargetVersion)
 ghcSet mtarget = do
-  AppState {dirs = Dirs {..}} <- ask
   ghc    <- parseRel $ E.encodeUtf8 (maybe "ghc" (<> "-ghc") mtarget)
-  let ghcBin = binDir </> ghc
+  ghcBin <- (</> ghc) <$> liftIO ghcupBinDir
 
   -- link destination is of the form ../ghc/<ver>/bin/ghc
-  -- for old ghcup, it is ../ghc/<ver>/bin/ghc-<ver>
+  liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ do
-  liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ do
     link <- readSymbolicLink $ toFilePath ghcBin
     Just <$> ghcLinkVersion link
-
-ghcLinkVersion :: MonadThrow m => ByteString -> m GHCTargetVersion
-ghcLinkVersion bs = do
-  t <- throwEither $ E.decodeUtf8' bs
-  throwEither $ MP.parse parser "ghcLinkVersion" t
  where
-  parser =
+  ghcLinkVersion :: MonadThrow m => ByteString -> m GHCTargetVersion
-      (do
+  ghcLinkVersion bs = do
-         _    <- parseUntil1 (MP.chunk "/ghc/")
+    t <- throwEither $ E.decodeUtf8' bs
-         _    <- MP.chunk "/ghc/"
+    throwEither $ MP.parse parser "" t
-         r    <- parseUntil1 (MP.chunk "/")
+   where
-         rest <- MP.getInput
+    parser =
-         MP.setInput r
+      MP.chunk "../ghc/"
-         x <- ghcTargetVerP
+        *> (do
-         MP.setInput rest
+             r    <- parseUntil1 (MP.chunk "/")
-         pure x
+             rest <- MP.getInput
-       )
+             MP.setInput r
-      <* MP.chunk "/"
+             x <- ghcTargetVerP
-      <* MP.takeRest
+             MP.setInput rest
-      <* MP.eof
+             pure x
+           )
+        <* MP.chunk "/bin/"
+        <* ghcTargetBinP "ghc"
+        <* MP.eof
 
 
 -- | Get all installed GHCs by reading ~/.ghcup/ghc/<dir>.
 -- If a dir cannot be parsed, returns left.
-getInstalledGHCs :: (MonadReader AppState m, MonadIO m) => m [Either (Path Rel) GHCTargetVersion]
+getInstalledGHCs :: MonadIO m => m [Either (Path Rel) GHCTargetVersion]
 getInstalledGHCs = do
-  ghcdir <- ghcupGHCBaseDir
+  ghcdir <- liftIO $ ghcupGHCBaseDir
   fs     <- liftIO $ hideErrorDef [NoSuchThing] [] $ getDirsFiles' ghcdir
   forM fs $ \f -> case parseGHCupGHCDir f of
     Right r -> pure $ Right r
     Left  _ -> pure $ Left f
 
 
--- | Get all installed cabals, by matching on @~\/.ghcup\/bin/cabal-*@.
+cabalInstalled :: Version -> IO Bool
-getInstalledCabals :: (MonadLogger m, MonadReader AppState m, MonadIO m, MonadCatch m)
-                   => m [Either (Path Rel) Version]
-getInstalledCabals = do
-  cs <- cabalSet -- for legacy cabal
-  getInstalledCabals' cs
-
-
-getInstalledCabals' :: (MonadLogger m, MonadReader AppState m, MonadIO m, MonadCatch m)
-                   => Maybe Version
-                   -> m [Either (Path Rel) Version]
-getInstalledCabals' cs = do
-  AppState {dirs = Dirs {..}} <- ask
-  bins   <- liftIO $ handleIO (\_ -> pure []) $ findFiles
-    binDir
-    (makeRegexOpts compExtended execBlank ([s|^cabal-.*$|] :: ByteString))
-  vs <- forM bins $ \f -> case fmap (version . decUTF8Safe) . B.stripPrefix "cabal-" . toFilePath $ f of
-    Just (Right r) -> pure $ Right r
-    Just (Left  _) -> pure $ Left f
-    Nothing        -> pure $ Left f
-  pure $ maybe vs (\x -> nub $ Right x:vs) cs
-
-
--- | Whether the given cabal version is installed.
-cabalInstalled :: (MonadLogger m, MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
 cabalInstalled ver = do
-  vers <- fmap rights getInstalledCabals
+  reportedVer <- cabalSet
-  pure $ elem ver vers
+  pure (reportedVer == ver)
 
-
+cabalSet :: (MonadIO m, MonadThrow m) => m Version
--- Return the currently set cabal version, if any.
-cabalSet :: (MonadLogger m, MonadReader AppState m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
 cabalSet = do
-  AppState {dirs = Dirs {..}} <- ask
+  cabalbin <- (</> [rel|cabal|]) <$> liftIO ghcupBinDir
-  let cabalbin = binDir </> [rel|cabal|]
+  mc       <- liftIO $ executeOut cabalbin ["--numeric-version"] Nothing
-  b        <- handleIO (\_ -> pure False) $ fmap (== SymbolicLink) $ liftIO $ getFileType cabalbin
+  let reportedVer = fst . B.spanEnd (== _lf) . _stdOut $ mc
-  if
+  case version $ decUTF8Safe reportedVer of
-    | b -> do
+    Left  e -> throwM e
-      handleIO' NoSuchThing (\_ -> pure Nothing) $ do
+    Right r -> pure r
-        broken <- liftIO $ isBrokenSymlink cabalbin
-        if broken
-          then do
-            $(logWarn) [i|Symlink #{cabalbin} is broken.|]
-            pure Nothing
-          else do
-            link <- liftIO $ readSymbolicLink $ toFilePath cabalbin
-            case linkVersion link of
-              Right v -> pure $ Just v
-              Left err -> do
-                $(logWarn) [i|Failed to parse cabal symlink target with: "#{err}". The symlink #{toFilePath cabalbin} needs to point to valid cabal binary, such as 'cabal-3.4.0.0'.|]
-                pure Nothing
-    | otherwise -> do -- legacy behavior
-      mc <- liftIO $ handleIO (\_ -> pure Nothing) $ fmap Just $ executeOut
-        cabalbin
-        ["--numeric-version"]
-        Nothing
-      fmap join $ forM mc $ \c -> if
-        | not (B.null (_stdOut c)), _exitCode c == ExitSuccess -> do
-          let reportedVer = fst . B.spanEnd (== _lf) . _stdOut $ c
-          case version $ decUTF8Safe reportedVer of
-            Left  e -> throwM e
-            Right r -> pure $ Just r
-        | otherwise -> pure Nothing
- where
-  -- We try to be extra permissive with link destination parsing,
-  -- because of:
-  --   https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/119
-  linkVersion :: MonadThrow m => ByteString -> m Version
-  linkVersion bs = do
-    t <- throwEither $ E.decodeUtf8' bs
-    throwEither $ MP.parse parser "" t
-
-  parser
-    =   MP.try (stripAbsolutePath *> cabalParse)
-    <|> MP.try (stripRelativePath *> cabalParse)
-    <|> cabalParse
-  -- parses the version of "cabal-3.2.0.0" -> "3.2.0.0"
-  cabalParse = MP.chunk "cabal-" *> version'
-  -- parses any path component ending with path separator,
-  -- e.g. "foo/"
-  stripPathComponet = parseUntil1 "/" *> MP.chunk "/"
-  -- parses an absolute path up until the last path separator,
-  -- e.g. "/bar/baz/foo" -> "/bar/baz/", leaving "foo"
-  stripAbsolutePath = MP.chunk "/" *> MP.many (MP.try stripPathComponet)
-  -- parses a relative path up until the last path separator,
-  -- e.g. "bar/baz/foo" -> "bar/baz/", leaving "foo"
-  stripRelativePath = MP.many (MP.try stripPathComponet)
-
-
-
--- | Get all installed hls, by matching on
--- @~\/.ghcup\/bin/haskell-language-server-wrapper-<\hlsver\>@.
-getInstalledHLSs :: (MonadReader AppState m, MonadIO m, MonadCatch m)
-                 => m [Either (Path Rel) Version]
-getInstalledHLSs = do
-  AppState { dirs = Dirs {..} } <- ask
-  bins                          <- liftIO $ handleIO (\_ -> pure []) $ findFiles
-    binDir
-    (makeRegexOpts compExtended
-                   execBlank
-                   ([s|^haskell-language-server-wrapper-.*$|] :: ByteString)
-    )
-  forM bins $ \f ->
-    case
-          fmap (version . decUTF8Safe) . B.stripPrefix "haskell-language-server-wrapper-" . toFilePath $ f
-      of
-        Just (Right r) -> pure $ Right r
-        Just (Left  _) -> pure $ Left f
-        Nothing        -> pure $ Left f
-
-
--- | Whether the given HLS version is installed.
-hlsInstalled :: (MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
-hlsInstalled ver = do
-  vers <- fmap rights getInstalledHLSs
-  pure $ elem ver vers
-
-
-
--- Return the currently set hls version, if any.
-hlsSet :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
-hlsSet = do
-  AppState {dirs = Dirs {..}} <- ask
-  let hlsBin = binDir </> [rel|haskell-language-server-wrapper|]
-
-  liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ do
-    broken <- isBrokenSymlink hlsBin
-    if broken
-      then pure Nothing
-      else do
-        link <- readSymbolicLink $ toFilePath hlsBin
-        Just <$> linkVersion link
- where
-  linkVersion :: MonadThrow m => ByteString -> m Version
-  linkVersion bs = do
-    t <- throwEither $ E.decodeUtf8' bs
-    throwEither $ MP.parse parser "" t
-   where
-    parser =
-      MP.chunk "haskell-language-server-wrapper-" *> version'
-
-
--- | Return the GHC versions the currently selected HLS supports.
-hlsGHCVersions :: ( MonadReader AppState m
-                  , MonadIO m
-                  , MonadThrow m
-                  , MonadCatch m
-                  )
-               => m [Version]
-hlsGHCVersions = do
-  h                             <- hlsSet
-  vers                          <- forM h $ \h' -> do
-    bins <- hlsServerBinaries h'
-    pure $ fmap
-      (version
-        . decUTF8Safe
-        . fromJust
-        . B.stripPrefix "haskell-language-server-"
-        . head
-        . B.split _tilde
-        . toFilePath
-      )
-      bins
-  pure . rights . concat . maybeToList $ vers
-
-
--- | Get all server binaries for an hls version, if any.
-hlsServerBinaries :: (MonadReader AppState m, MonadIO m)
-                  => Version
-                  -> m [Path Rel]
-hlsServerBinaries ver = do
-  AppState { dirs = Dirs {..} } <- ask
-  liftIO $ handleIO (\_ -> pure []) $ findFiles
-    binDir
-    (makeRegexOpts
-      compExtended
-      execBlank
-      ([s|^haskell-language-server-.*~|] <> escapeVerRex ver <> [s|$|] :: ByteString
-      )
-    )
-
-
--- | Get the wrapper binary for an hls version, if any.
-hlsWrapperBinary :: (MonadReader AppState m, MonadThrow m, MonadIO m)
-                 => Version
-                 -> m (Maybe (Path Rel))
-hlsWrapperBinary ver = do
-  AppState { dirs = Dirs {..} } <- ask
-  wrapper                       <- liftIO $ handleIO (\_ -> pure []) $ findFiles
-    binDir
-    (makeRegexOpts
-      compExtended
-      execBlank
-      ([s|^haskell-language-server-wrapper-|] <> escapeVerRex ver <> [s|$|] :: ByteString
-      )
-    )
-  case wrapper of
-    []  -> pure Nothing
-    [x] -> pure $ Just x
-    _   -> throwM $ UnexpectedListLength
-      "There were multiple hls wrapper binaries for a single version"
-
-
--- | Get all binaries for an hls version, if any.
-hlsAllBinaries :: (MonadReader AppState m, MonadIO m, MonadThrow m) => Version -> m [Path Rel]
-hlsAllBinaries ver = do
-  hls     <- hlsServerBinaries ver
-  wrapper <- hlsWrapperBinary ver
-  pure (maybeToList wrapper ++ hls)
-
-
--- | Get the active symlinks for hls.
-hlsSymlinks :: (MonadReader AppState m, MonadIO m, MonadCatch m) => m [Path Rel]
-hlsSymlinks = do
-  AppState { dirs = Dirs {..} } <- ask
-  oldSyms                       <- liftIO $ handleIO (\_ -> pure []) $ findFiles
-    binDir
-    (makeRegexOpts compExtended
-                   execBlank
-                   ([s|^haskell-language-server-.*$|] :: ByteString)
-    )
-  filterM
-    ( fmap (== SymbolicLink)
-    . liftIO
-    . getFileType
-    . (binDir </>)
-    )
-    oldSyms
 
 
 
@@ -485,10 +230,9 @@ hlsSymlinks = do
     -----------------------------------------
 
 
--- | Extract (major, minor) from any version.
 getMajorMinorV :: MonadThrow m => Version -> m (Int, Int)
 getMajorMinorV Version {..} = case _vChunks of
-  ((Digits x :| []) :| ((Digits y :| []):_)) -> pure (fromIntegral x, fromIntegral y)
+  ([Digits x] : [Digits y] : _) -> pure (fromIntegral x, fromIntegral y)
   _ -> throwM $ ParseError "Could not parse X.Y from version"
 
 
@@ -500,7 +244,7 @@ matchMajor v' major' minor' = case getMajorMinorV v' of
 
 -- | Get the latest installed full GHC version that satisfies X.Y.
 -- This reads `ghcupGHCBaseDir`.
-getGHCForMajor :: (MonadReader AppState m, MonadIO m, MonadThrow m)
+getGHCForMajor :: (MonadIO m, MonadThrow m)
                => Int        -- ^ major version component
                -> Int        -- ^ minor version component
                -> Maybe Text -- ^ the target triple
@@ -522,9 +266,13 @@ getGHCForMajor major' minor' mt = do
 getLatestGHCFor :: Int -- ^ major version component
                 -> Int -- ^ minor version component
                 -> GHCupDownloads
-                -> Maybe (Version, VersionInfo)
+                -> Maybe Version
-getLatestGHCFor major' minor' dls =
+getLatestGHCFor major' minor' dls = do
-  preview (ix GHC % to Map.toDescList) dls >>= lastMay . filter (\(v, _) -> matchMajor v major' minor')
+  join
+    . fmap (lastMay . filter (\v -> matchMajor v major' minor'))
+    . preview (ix GHC % to Map.keys)
+    $ dls
+
 
 
 
@@ -539,113 +287,28 @@ getLatestGHCFor major' minor' dls =
 unpackToDir :: (MonadLogger m, MonadIO m, MonadThrow m)
             => Path Abs       -- ^ destination dir
             -> Path Abs       -- ^ archive path
-            -> Excepts '[UnknownArchive
+            -> Excepts '[UnknownArchive] m ()
-#if !defined(TAR)
-                        , ArchiveResult
-#endif
-                        ] m ()
 unpackToDir dest av = do
-  fp <- decUTF8Safe . toFilePath <$> basename av
+  fp <- (decUTF8Safe . toFilePath) <$> basename av
   let dfp = decUTF8Safe . toFilePath $ dest
   lift $ $(logInfo) [i|Unpacking: #{fp} to #{dfp}|]
   fn <- toFilePath <$> basename av
-
+  let untar = Tar.unpack (toFilePath dest) . Tar.read
-#if defined(TAR)
-  let untar :: MonadIO m => BL.ByteString -> Excepts '[] m ()
-      untar = liftIO . Tar.unpack (toFilePath dest) . Tar.read
-
-      rf :: MonadIO m => Path Abs -> Excepts '[] m BL.ByteString
-      rf = liftIO . readFile
-#else
-  let untar :: MonadIO m => BL.ByteString -> Excepts '[ArchiveResult] m ()
-      untar = lEM . liftIO . runArchiveM . unpackToDirLazy (T.unpack . decUTF8Safe . toFilePath $ dest)
-
-      rf :: MonadIO m => Path Abs -> Excepts '[ArchiveResult] m BL.ByteString
-      rf = liftIO . readFile
-#endif
 
   -- extract, depending on file extension
   if
-    | ".tar.gz" `B.isSuffixOf` fn -> liftE
+    | ".tar.gz" `B.isSuffixOf` fn -> liftIO
-      (untar . GZip.decompress =<< rf av)
+      (untar . GZip.decompress =<< readFile av)
     | ".tar.xz" `B.isSuffixOf` fn -> do
-      filecontents <- liftE $ rf av
+      filecontents <- liftIO $ readFile av
       let decompressed = Lzma.decompress filecontents
-      liftE $ untar decompressed
+      liftIO $ untar decompressed
-    | ".tar.bz2" `B.isSuffixOf` fn ->
+    | ".tar.bz2" `B.isSuffixOf` fn -> liftIO
-      liftE (untar . BZip.decompress =<< rf av)
+      (untar . BZip.decompress =<< readFile av)
-    | ".tar" `B.isSuffixOf` fn -> liftE (untar =<< rf av)
+    | ".tar" `B.isSuffixOf` fn -> liftIO (untar =<< readFile av)
     | otherwise -> throwE $ UnknownArchive fn
 
 
-getArchiveFiles :: (MonadLogger m, MonadIO m, MonadThrow m)
-                => Path Abs       -- ^ archive path
-                -> Excepts '[UnknownArchive
-#if defined(TAR)
-                            , Tar.FormatError
-#else
-                            , ArchiveResult
-#endif
-                            ] m [ByteString]
-getArchiveFiles av = do
-  fn <- toFilePath <$> basename av
-
-#if defined(TAR)
-  let entries :: Monad m => BL.ByteString -> Excepts '[Tar.FormatError] m [ByteString]
-      entries =
-          lE @Tar.FormatError
-          . Tar.foldEntries
-            (\e x -> fmap (Tar.entryPath e :) x)
-            (Right [])
-            (\e -> Left e)
-          . Tar.read
-
-      rf :: MonadIO m => Path Abs -> Excepts '[Tar.FormatError] m BL.ByteString
-      rf = liftIO . readFile
-#else
-  let entries :: Monad m => BL.ByteString -> Excepts '[ArchiveResult] m [ByteString]
-      entries = (fmap . fmap) (E.encodeUtf8 . T.pack . filepath) . lE . readArchiveBSL
-
-      rf :: MonadIO m => Path Abs -> Excepts '[ArchiveResult] m BL.ByteString
-      rf = liftIO . readFile
-#endif
-
-  -- extract, depending on file extension
-  if
-    | ".tar.gz" `B.isSuffixOf` fn -> liftE
-      (entries . GZip.decompress =<< rf av)
-    | ".tar.xz" `B.isSuffixOf` fn -> do
-      filecontents <- liftE $ rf av
-      let decompressed = Lzma.decompress filecontents
-      liftE $ entries decompressed
-    | ".tar.bz2" `B.isSuffixOf` fn ->
-      liftE (entries . BZip.decompress =<< rf av)
-    | ".tar" `B.isSuffixOf` fn -> liftE (entries =<< rf av)
-    | otherwise -> throwE $ UnknownArchive fn
-
-
-intoSubdir :: (MonadLogger m, MonadIO m, MonadThrow m, MonadCatch m)
-           => Path Abs       -- ^ unpacked tar dir
-           -> TarDir         -- ^ how to descend
-           -> Excepts '[TarDirDoesNotExist] m (Path Abs)
-intoSubdir bdir tardir = case tardir of
-  RealDir pr -> do
-    whenM (fmap not . liftIO . doesDirectoryExist $ (bdir </> pr))
-          (throwE $ TarDirDoesNotExist tardir)
-    pure (bdir </> pr)
-  RegexDir r -> do
-    let rs = splitOn "/" r
-    foldlM
-      (\y x ->
-        (handleIO (\_ -> pure []) . liftIO . findFiles y . regex $ x) >>= (\case
-          []      -> throwE $ TarDirDoesNotExist tardir
-          (p : _) -> pure (y </> p)) . sort
-      )
-      bdir
-      rs
-    where regex = makeRegexOpts compIgnoreCase execBlank
-
-
 
 
     ------------
@@ -658,35 +321,32 @@ intoSubdir bdir tardir = case tardir of
 getTagged :: Tag
           -> AffineFold (Map.Map Version VersionInfo) (Version, VersionInfo)
 getTagged tag =
-  to (Map.filter (\VersionInfo {..} -> tag `elem` _viTags))
+  ( to (Map.filter (\VersionInfo {..} -> elem tag _viTags))
   % to Map.toDescList
   % _head
+  )
 
-getLatest :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
+getLatest :: GHCupDownloads -> Tool -> Maybe Version
-getLatest av tool = headOf (ix tool % getTagged Latest) av
+getLatest av tool = headOf (ix tool % getTagged Latest % to fst) $ av
 
-getRecommended :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
+getRecommended :: GHCupDownloads -> Tool -> Maybe Version
-getRecommended av tool = headOf (ix tool % getTagged Recommended) av
+getRecommended av tool = headOf (ix tool % getTagged Recommended % to fst) $ av
 
 
 -- | Gets the latest GHC with a given base version.
-getLatestBaseVersion :: GHCupDownloads -> PVP -> Maybe (Version, VersionInfo)
+getLatestBaseVersion :: GHCupDownloads -> PVP -> Maybe Version
 getLatestBaseVersion av pvpVer =
-  headOf (ix GHC % getTagged (Base pvpVer)) av
+  headOf (ix GHC % getTagged (Base pvpVer) % to fst) av
 
 
 
     -----------------------
-    --[ AppState Getter ]--
+    --[ Settings Getter ]--
     -----------------------
 
 
-getCache :: MonadReader AppState m => m Bool
+getCache :: MonadReader Settings m => m Bool
-getCache = ask <&> cache . settings
+getCache = ask <&> cache
-
-
-getDownloader :: MonadReader AppState m => m Downloader
-getDownloader = ask <&> downloader . settings
 
 
 
@@ -701,22 +361,21 @@ urlBaseName :: MonadThrow m
 urlBaseName = parseRel . snd . B.breakEnd (== _slash) . urlDecode False
 
 
--- | Get tool files from @~\/.ghcup\/bin\/ghc\/\<ver\>\/bin\/\*@
+-- Get tool files from '~/.ghcup/bin/ghc/<ver>/bin/*'
--- while ignoring @*-\<ver\>@ symlinks and accounting for cross triple prefix.
+-- while ignoring *-<ver> symlinks and accounting for cross triple prefix.
 --
 -- Returns unversioned relative files, e.g.:
---
+--   ["hsc2hs","haddock","hpc","runhaskell","ghc","ghc-pkg","ghci","runghc","hp2ps"]
---   - @["hsc2hs","haddock","hpc","runhaskell","ghc","ghc-pkg","ghci","runghc","hp2ps"]@
+ghcToolFiles :: (MonadThrow m, MonadFail m, MonadIO m)
-ghcToolFiles :: (MonadReader AppState m, MonadThrow m, MonadFail m, MonadIO m)
              => GHCTargetVersion
              -> Excepts '[NotInstalled] m [Path Rel]
 ghcToolFiles ver = do
-  ghcdir <- lift $ ghcupGHCDir ver
+  ghcdir <- liftIO $ ghcupGHCDir ver
   let bindir = ghcdir </> [rel|bin|]
 
   -- fail if ghc is not installed
   whenM (fmap not $ liftIO $ doesDirectoryExist ghcdir)
-        (throwE (NotInstalled GHC ver))
+        (throwE (NotInstalled GHC (prettyTVer ver)))
 
   files    <- liftIO $ getDirsFiles' bindir
   -- figure out the <ver> suffix, because this might not be `Version` for
@@ -731,42 +390,26 @@ ghcToolFiles ver = do
                    ([s|^([a-zA-Z0-9_-]*[a-zA-Z0-9_]-)?ghc$|] :: ByteString)
     )
 
-  let ghcbinPath = bindir </> ghcbin
+  (Just symver) <-
-  ghcIsHadrian    <- liftIO $ isHadrian ghcbinPath
+    (B.stripPrefix (toFilePath ghcbin <> "-") . takeFileName)
-  onlyUnversioned <- if ghcIsHadrian
+      <$> (liftIO $ readSymbolicLink $ toFilePath (bindir </> ghcbin))
-    then pure id
+  when (B.null symver)
-    else do
+       (throwIO $ userError $ "Fatal: ghc symlink target is broken")
-      (Just symver) <-
-        B.stripPrefix (toFilePath ghcbin <> "-") . takeFileName
-          <$> liftIO (readSymbolicLink $ toFilePath ghcbinPath)
-      when (B.null symver)
-           (throwIO $ userError "Fatal: ghc symlink target is broken")
-      pure $ filter (\x -> not $ symver `B.isSuffixOf` toFilePath x)
 
-  pure $ onlyUnversioned files
+  pure . filter (\x -> not $ symver `B.isSuffixOf` toFilePath x) $ files
- where
-    -- GHC is moving some builds to Hadrian for bindists,
-    -- which doesn't create versioned binaries.
-    -- https://gitlab.haskell.org/haskell/ghcup-hs/issues/31
-  isHadrian :: Path Abs -- ^ ghcbin path
-            -> IO Bool
-  isHadrian = fmap (/= SymbolicLink) . getFileType
 
 
--- | This file, when residing in @~\/.ghcup\/ghc\/\<ver\>\/@ signals that
+-- | This file, when residing in ~/.ghcup/ghc/<ver>/ signals that
 -- this GHC was built from source. It contains the build config.
 ghcUpSrcBuiltFile :: Path Rel
 ghcUpSrcBuiltFile = [rel|.ghcup_src_built|]
 
 
 -- | Calls gmake if it exists in PATH, otherwise make.
-make :: (MonadThrow m, MonadIO m, MonadReader AppState m)
+make :: [ByteString] -> Maybe (Path Abs) -> IO (Either ProcessError ())
-     => [ByteString]
-     -> Maybe (Path Abs)
-     -> m (Either ProcessError ())
 make args workdir = do
-  spaths    <- catMaybes . fmap parseAbs <$> liftIO getSearchPath
+  spaths    <- catMaybes . fmap parseAbs <$> getSearchPath
-  has_gmake <- isJust <$> liftIO (searchPath spaths [rel|gmake|])
+  has_gmake <- isJust <$> searchPath spaths [rel|gmake|]
   let mymake = if has_gmake then "gmake" else "make"
   execLogged mymake True args [rel|ghc-make|] workdir Nothing
 
@@ -781,17 +424,16 @@ applyPatches pdir ddir = do
   patches <- liftIO $ getDirsFiles pdir
   forM_ (sort patches) $ \patch' -> do
     lift $ $(logInfo) [i|Applying patch #{patch'}|]
-    fmap (either (const Nothing) Just)
+    (fmap (either (const Nothing) Just) $ liftIO $ exec
-         (liftIO $ exec
+        "patch"
-           "patch"
+        True
-           True
+        ["-p1", "-i", toFilePath patch']
-           ["-p1", "-i", toFilePath patch']
+        (Just ddir)
-           (Just ddir)
+        Nothing
-           Nothing)
+      )
       !? PatchFailed
 
 
--- | https://gitlab.haskell.org/ghc/ghc/-/issues/17353
 darwinNotarization :: Platform -> Path Abs -> IO (Either ProcessError ())
 darwinNotarization Darwin path = exec
   "xattr"
@@ -813,71 +455,34 @@ getChangeLog dls tool (Right tag) =
 --
 --   1. the build directory, depending on the KeepDirs setting
 --   2. the install destination, depending on whether the build failed
-runBuildAction :: (Show (V e), MonadReader AppState m, MonadIO m, MonadMask m)
+runBuildAction :: (Show (V e), MonadReader Settings m, MonadIO m, MonadMask m)
-               => Path Abs          -- ^ build directory (cleaned up depending on Settings)
+               => Path Abs          -- ^ build directory
-               -> Maybe (Path Abs)  -- ^ dir to *always* clean up on exception
+               -> Maybe (Path Abs)  -- ^ install location (e.g. for GHC)
-               -> Excepts e m a
+               -> Excepts e m ()
-               -> Excepts '[BuildFailed] m a
+               -> Excepts '[BuildFailed] m ()
 runBuildAction bdir instdir action = do
-  AppState { settings = Settings {..} } <- lift ask
+  Settings {..} <- lift ask
-  let exAction = do
+  flip
+      onException
+      (do
         forM_ instdir $ \dir ->
           liftIO $ hideError doesNotExistErrorType $ deleteDirRecursive dir
         when (keepDirs == Never)
           $ liftIO
           $ hideError doesNotExistErrorType
           $ deleteDirRecursive bdir
-  v <-
+      )
-    flip onException exAction
     $ catchAllE
         (\es -> do
-          exAction
+          forM_ instdir $ \dir ->
+            liftIO $ hideError doesNotExistErrorType $ deleteDirRecursive dir
+          when (keepDirs == Never)
+            $ liftIO
+            $ hideError doesNotExistErrorType
+            $ deleteDirRecursive bdir
           throwE (BuildFailed bdir es)
-        ) action
+        )
+    $ action
 
   when (keepDirs == Never || keepDirs == Errors) $ liftIO $ deleteDirRecursive
     bdir
-  pure v
-
-
--- | More permissive version of 'createDirRecursive'. This doesn't
--- error when the destination is a symlink to a directory.
-createDirRecursive' :: Path b -> IO ()
-createDirRecursive' p =
-  handleIO (\e -> if isAlreadyExistsError e then isSymlinkDir e else throwIO e)
-    . createDirRecursive newDirPerms
-    $ p
-
- where
-  isSymlinkDir e = do
-    ft <- getFileType p
-    case ft of
-      SymbolicLink -> do
-        rp <- canonicalizePath p
-        rft <- getFileType rp
-        case rft of
-          Directory -> pure ()
-          _ -> throwIO e
-      _ -> throwIO e
-
-
-getVersionInfo :: Version
-               -> Tool
-               -> GHCupDownloads
-               -> Maybe VersionInfo
-getVersionInfo v' tool =
-  headOf
-    ( ix tool
-    % to (Map.filterWithKey (\k _ -> k == v'))
-    % to Map.elems
-    % _head
-    )
-
-
--- 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)

lib/GHCup/Utils/Bash.hs

@@ -0,0 +1,69 @@
+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,32 +1,10 @@
-{-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE OverloadedStrings     #-}
-{-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE ViewPatterns          #-}
 
-{-|
+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 : POSIX
--}
-module GHCup.Utils.Dirs
-  ( getDirs
-  , ghcupConfigFile
-  , ghcupGHCBaseDir
-  , ghcupGHCDir
-  , mkGhcupTmpDir
-  , parseGHCupGHCDir
-  , relativeSymlink
-  , withGHCupTmpDir
-  )
-where
 
 
-import           GHCup.Errors
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.MegaParsec
@@ -37,11 +15,7 @@ import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
-import           Data.Bifunctor
-import           Data.ByteString                ( ByteString )
 import           Data.Maybe
-import           GHC.IO.Exception               ( IOErrorType(NoSuchThing) )
-import           Haskus.Utils.Variant.Excepts
 import           HPath
 import           HPath.IO
 import           Optics
@@ -52,169 +26,43 @@ import           Prelude                 hiding ( abs
 import           System.Posix.Env.ByteString    ( getEnv
                                                 , getEnvDefault
                                                 )
-import           System.Posix.FilePath   hiding ( (</>) )
 import           System.Posix.Temp.ByteString   ( mkdtemp )
 
-import qualified Data.ByteString.Lazy          as L
 import qualified Data.ByteString.UTF8          as UTF8
 import qualified Data.Text.Encoding            as E
-import qualified Data.Yaml                     as Y
 import qualified System.Posix.FilePath         as FP
 import qualified System.Posix.User             as PU
 import qualified Text.Megaparsec               as MP
 
 
 
-    ------------------------------
-    --[ 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 (Path Abs)
-ghcupBaseDir = do
-  xdg <- useXDG
-  if xdg
-    then do
-      bdir <- getEnv "XDG_DATA_HOME" >>= \case
-        Just r  -> parseAbs r
-        Nothing -> do
-          home <- liftIO getHomeDirectory
-          pure (home </> [rel|.local/share|])
-      pure (bdir </> [rel|ghcup|])
-    else do
-      bdir <- getEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
-        Just r  -> parseAbs r
-        Nothing -> liftIO getHomeDirectory
-      pure (bdir </> [rel|.ghcup|])
-
-
--- | ~/.ghcup by default
---
--- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
--- then uses 'XDG_CONFIG_HOME/ghcup' as per xdg spec.
-ghcupConfigDir :: IO (Path Abs)
-ghcupConfigDir = do
-  xdg <- useXDG
-  if xdg
-    then do
-      bdir <- getEnv "XDG_CONFIG_HOME" >>= \case
-        Just r  -> parseAbs r
-        Nothing -> do
-          home <- liftIO getHomeDirectory
-          pure (home </> [rel|.config|])
-      pure (bdir </> [rel|ghcup|])
-    else do
-      bdir <- getEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
-        Just r  -> parseAbs r
-        Nothing -> liftIO getHomeDirectory
-      pure (bdir </> [rel|.ghcup|])
-
-
--- | 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 (Path Abs)
-ghcupBinDir = do
-  xdg <- useXDG
-  if xdg
-    then do
-      getEnv "XDG_BIN_HOME" >>= \case
-        Just r  -> parseAbs r
-        Nothing -> do
-          home <- liftIO getHomeDirectory
-          pure (home </> [rel|.local/bin|])
-    else ghcupBaseDir <&> (</> [rel|bin|])
-
-
--- | 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 (Path Abs)
-ghcupCacheDir = do
-  xdg <- useXDG
-  if xdg
-    then do
-      bdir <- getEnv "XDG_CACHE_HOME" >>= \case
-        Just r  -> parseAbs r
-        Nothing -> do
-          home <- liftIO getHomeDirectory
-          pure (home </> [rel|.cache|])
-      pure (bdir </> [rel|ghcup|])
-    else ghcupBaseDir <&> (</> [rel|cache|])
-
-
--- | 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 (Path Abs)
-ghcupLogsDir = do
-  xdg <- useXDG
-  if xdg
-    then do
-      bdir <- getEnv "XDG_CACHE_HOME" >>= \case
-        Just r  -> parseAbs r
-        Nothing -> do
-          home <- liftIO getHomeDirectory
-          pure (home </> [rel|.cache|])
-      pure (bdir </> [rel|ghcup/logs|])
-    else ghcupBaseDir <&> (</> [rel|logs|])
-
-
-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 </> [rel|config.yaml|]
-  bs <- liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ Just <$> readFile file
-  case bs of
-      Nothing -> pure defaultUserSettings
-      Just bs' -> lE' JSONDecodeError . first show . Y.decodeEither' . L.toStrict $ bs'
-
-
     -------------------------
     --[ GHCup directories ]--
     -------------------------
 
 
+-- | ~/.ghcup by default
+ghcupBaseDir :: IO (Path Abs)
+ghcupBaseDir = do
+  bdir <- getEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
+    Just r  -> parseAbs r
+    Nothing -> liftIO getHomeDirectory
+  pure (bdir </> [rel|.ghcup|])
+
+
 -- | ~/.ghcup/ghc by default.
-ghcupGHCBaseDir :: (MonadReader AppState m) => m (Path Abs)
+ghcupGHCBaseDir :: IO (Path Abs)
-ghcupGHCBaseDir = do
+ghcupGHCBaseDir = ghcupBaseDir <&> (</> [rel|ghc|])
-  AppState { dirs = Dirs {..} } <- ask
-  pure (baseDir </> [rel|ghc|])
 
 
 -- | 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)
+ghcupGHCDir :: GHCTargetVersion -> IO (Path Abs)
-            => GHCTargetVersion
-            -> m (Path Abs)
 ghcupGHCDir ver = do
-  ghcbasedir    <- ghcupGHCBaseDir
+  ghcbasedir <- ghcupGHCBaseDir
-  verdir        <- parseRel $ E.encodeUtf8 (tVerToText ver)
+  verdir     <- parseRel $ E.encodeUtf8 (prettyTVer ver)
   pure (ghcbasedir </> verdir)
 
 
@@ -225,10 +73,20 @@ parseGHCupGHCDir (toFilePath -> f) = do
   throwEither $ MP.parse ghcTargetVerP "" fp
 
 
+ghcupBinDir :: IO (Path Abs)
+ghcupBinDir = ghcupBaseDir <&> (</> [rel|bin|])
+
+ghcupCacheDir :: IO (Path Abs)
+ghcupCacheDir = ghcupBaseDir <&> (</> [rel|cache|])
+
+ghcupLogsDir :: IO (Path Abs)
+ghcupLogsDir = ghcupBaseDir <&> (</> [rel|logs|])
+
+
 mkGhcupTmpDir :: (MonadThrow m, MonadIO m) => m (Path Abs)
 mkGhcupTmpDir = do
   tmpdir <- liftIO $ getEnvDefault "TMPDIR" "/tmp"
-  tmp    <- liftIO $ mkdtemp (tmpdir FP.</> "ghcup-")
+  tmp    <- liftIO $ mkdtemp $ (tmpdir FP.</> "ghcup-")
   parseAbs tmp
 
 
@@ -236,8 +94,6 @@ withGHCupTmpDir :: (MonadResource m, MonadThrow m, MonadIO m) => m (Path Abs)
 withGHCupTmpDir = snd <$> allocate mkGhcupTmpDir deleteDirRecursive
 
 
-
-
     --------------
     --[ Others ]--
     --------------
@@ -251,23 +107,3 @@ getHomeDirectory = do
     Nothing -> do
       h <- PU.homeDirectory <$> (PU.getEffectiveUserID >>= PU.getUserEntryForID)
       parseAbs $ UTF8.fromString h -- this is a guess
-
-
-useXDG :: IO Bool
-useXDG = isJust <$> getEnv "GHCUP_USE_XDG_DIRS"
-
-
-relativeSymlink :: Path Abs  -- ^ the path in which to create the symlink
-                -> Path Abs  -- ^ the symlink destination
-                -> ByteString
-relativeSymlink (toFilePath -> p1) (toFilePath -> 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 ("/" : drop (length common) d2)
-
-
-
-

lib/GHCup/Utils/File.hs

@@ -1,94 +1,81 @@
 {-# LANGUAGE QuasiQuotes       #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE FlexibleContexts  #-}
 {-# LANGUAGE TemplateHaskell   #-}
-{-# LANGUAGE ViewPatterns      #-}
 
-{-|
-Module      : GHCup.Utils.File
-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 where
 
+import           GHCup.Utils.Dirs
 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.ByteString.Unsafe         ( unsafeUseAsCStringLen )
+import           Data.Char
 import           Data.Foldable
 import           Data.Functor
 import           Data.IORef
 import           Data.Maybe
-import           Data.Sequence                  ( Seq, (|>) )
-import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Void
-import           Data.Word8
+import           GHC.Foreign                    ( peekCStringLen )
+import           GHC.IO.Encoding                ( getLocaleEncoding )
 import           GHC.IO.Exception
 import           HPath
-import           HPath.IO                hiding ( hideError )
+import           HPath.IO
-import           Optics                  hiding ((<|), (|>))
+import           Optics
-import           System.Console.Pretty   hiding ( Pretty )
+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.Files.ByteString
 import           System.Posix.Foreign           ( oExcl )
 import "unix"    System.Posix.IO.ByteString
                                          hiding ( openFd )
 import           System.Posix.Process           ( ProcessStatus(..) )
 import           System.Posix.Types
-import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
 import           Text.Regex.Posix
 
 
 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.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 Text.Megaparsec               as MP
 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
 
-instance Pretty ProcessError where
-  pPrint (NonZeroExit e exe args) =
-    text [i|Process "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args} failed with exit code #{e}.|]
-  pPrint (PTerminated exe args) =
-    text [i|Process "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args} terminated.|]
-  pPrint (PStopped exe args) =
-    text [i|Process "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args} stopped.|]
-  pPrint (NoSuchPid exe args) =
-    text [i|Could not find PID for process running "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args}.|]
 
 data CapturedProcess = CapturedProcess
   { _exitCode :: ExitCode
@@ -100,6 +87,25 @@ data CapturedProcess = CapturedProcess
 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.
 --
@@ -107,14 +113,12 @@ makeLenses ''CapturedProcess
 -- PATH does.
 findExecutable :: Path Rel -> IO (Maybe (Path Abs))
 findExecutable ex = do
-  sPaths <- fmap (catMaybes . fmap parseAbs) getSearchPath
+  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
+  asum $ fmap (handleIO (\_ -> pure Nothing)) $ fmap
-    (handleIO (\_ -> pure Nothing)
+    -- asum for short-circuiting behavior
-      -- asum for short-circuiting behavior
+    (\s' -> (isExecutable (s' </> ex) >>= guard) $> (Just (s' </> ex)))
-      . (\s' -> (isExecutable (s' </> ex) >>= guard) $> Just (s' </> ex))
-    )
     sPaths
 
 
@@ -129,156 +133,110 @@ executeOut path args chdir = captureOutStreams $ do
   SPPB.executeFile (toFilePath path) True args Nothing
 
 
-execLogged :: (MonadReader AppState m, MonadIO m, MonadThrow m)
+execLogged :: ByteString       -- ^ thing to execute
-           => 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
-           -> m (Either ProcessError ())
+           -> IO (Either ProcessError ())
 execLogged exe spath args lfile chdir env = do
-  AppState { settings = Settings {..}, dirs = Dirs {..} } <- ask
+  ldir    <- ghcupLogsDir
-  logfile       <- (logsDir </>) <$> parseRel (toFilePath lfile <> ".log")
+  logfile <- (ldir </>) <$> parseRel (toFilePath lfile <> ".log")
-  liftIO $ bracket (createFile (toFilePath logfile) newFilePerms)
+  bracket (createFile (toFilePath logfile) newFilePerms) closeFd action
-                   closeFd
-                   (action verbose)
  where
-  action verbose fd = do
+  action fd = do
     actionWithPipes $ \(stdoutRead, stdoutWrite) -> do
-      -- start the thread that logs to stdout
+      -- start the thread that logs to stdout in a region
-      pState <- newEmptyMVar
+      done <- newEmptyMVar
-      done   <- newEmptyMVar
+      tid  <-
-      void
+        forkIO
-        $ forkIO
+        $ EX.handle (\(_ :: StopThread) -> pure ())
         $ EX.handle (\(_ :: IOException) -> pure ())
-        $ EX.finally
+        $ flip finally (putMVar done ())
-            (if verbose
+        $ printToRegion fd stdoutRead 6
-              then tee fd stdoutRead
-              else printToRegion fd stdoutRead 6 pState
-            )
-            (putMVar done ())
 
-      -- fork the subprocess
+      -- fork our subprocess
       pid <- SPPB.forkProcess $ do
         void $ dupTo stdoutWrite stdOutput
         void $ dupTo stdoutWrite stdError
-        closeFd stdoutRead
         closeFd stdoutWrite
+        closeFd stdoutRead
 
         -- execute the action
         maybe (pure ()) (changeWorkingDirectory . toFilePath) chdir
-        void $ SPPB.executeFile exe spath args env
+        SPPB.executeFile exe spath args env
 
       closeFd stdoutWrite
 
       -- wait for the subprocess to finish
-      e <- toProcessError exe args <$!> SPPB.getProcessStatus True True pid
+      e <- SPPB.getProcessStatus True True pid >>= \case
-      putMVar pState (either (const False) (const True) e)
+        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
 
-      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 = do
-  printToRegion fileFd fdIn size pState = do
+    ref <- newIORef ([] :: [ByteString])
-    void $ displayConsoleRegions $ do
+    displayConsoleRegions $ do
-      rs <-
+      rs <- sequence . replicate size . openConsoleRegion $ Linear
-        liftIO
+      flip finally (readTilEOF (lineAction ref rs) fdIn) -- make sure the last few lines don't get cut off
-        . fmap Sq.fromList
-        . sequence
-        . replicate size
-        . openConsoleRegion
-        $ Linear
-      flip runStateT mempty
         $ handle
-            (\(ex :: SomeException) -> do
+            (\(StopThread b) -> do
-              ps <- liftIO $ takeMVar pState
+              when b (forM_ rs closeConsoleRegion)
-              when ps (forM_ rs (liftIO . closeConsoleRegion))
+              EX.throw (StopThread b)
-              throw ex
             )
-        $ readTilEOF (lineAction rs) fdIn
+        $ 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
-    -- TODO: do this with vty for efficiency
+    lineAction ref rs bs' = do
-    lineAction :: (MonadMask m, MonadIO m)
+      modifyIORef' ref (swapRegs bs')
-               => Seq ConsoleRegion
+      regs <- readIORef ref
-               -> ByteString
+      void $ SPIB.fdWrite fileFd (bs' <> "\n")
-               -> StateT (Seq ByteString) m ()
+      forM (zip regs rs) $ \(bs, r) -> do
-    lineAction rs = \bs' -> do
+        setConsoleRegion r $ do
-      void $ liftIO $ SPIB.fdWrite fileFd (bs' <> "\n")
+          w <- consoleWidth
-      modify (swapRegs bs')
+          return
-      regs <- get
+            . T.pack
-      liftIO $ forM_ (Sq.zip regs rs) $ \(bs, r) -> setConsoleRegion r $ do
+            . color Blue
-        w <- consoleWidth
+            . T.unpack
-        return
+            . decUTF8Safe
-          . T.pack
+            . trim w
-          . color Blue
+            . (\b -> "[ " <> toFilePath lfile <> " ] " <> b)
-          . T.unpack
+            $ bs
-          . decUTF8Safe
-          . trim w
-          . (\b -> "[ " <> toFilePath lfile <> " ] " <> b)
-          $ bs
 
-    swapRegs :: a -> Seq a -> Seq a
+    swapRegs bs regs | length regs < size = regs ++ [bs]
-    swapRegs bs = \regs -> if
+                     | otherwise          = tail regs ++ [bs]
-      | 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 | BS.length bs > w && w > 5 = BS.take (w - 4) bs <> "..."
-    trim w = \bs -> if
+              | otherwise                 = bs
-      | BS.length bs > w && w > 5 -> BS.take (w - 4) bs <> "..."
-      | otherwise                 -> bs
 
-  -- Consecutively read from Fd in 512 chunks until we hit
+    -- read an entire line from the file descriptor (removes the newline char)
-  -- newline or EOF.
+    readLine fd' = do
-  readLine :: MonadIO m
+      bs <- SPIB.fdRead fd' 1
-           => Fd          -- ^ input file descriptor
+      if
-           -> ByteString  -- ^ rest buffer (read across newline)
+        | bs == "\n" -> pure ""
-           -> m (ByteString, ByteString, Bool) -- ^ (full line, rest, eof)
+        | bs == ""   -> pure ""
-  readLine fd = go
+        | otherwise  -> fmap (bs <>) $ readLine fd'
-   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' = do
-  readTilEOF ~action' fd' = go mempty
+      bs <- readLine fd'
-   where
+      void $ action' bs
-    go bs' = do
+      readTilEOF action' fd'
-      (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
@@ -315,12 +273,13 @@ captureOutStreams action = do
       done   <- newEmptyMVar
       _      <-
         forkIO
+        $ EX.handle (\(_ :: StopThread) -> pure ())
         $ EX.handle (\(_ :: IOException) -> pure ())
-        $ flip EX.finally (putMVar done ())
+        $ flip finally (putMVar done ())
         $ writeStds parentStdoutRead parentStderrRead refOut refErr
 
       status <- SPPB.getProcessStatus True True pid
-      void $ race (takeMVar done) (threadDelay (1000000 * 3))
+      takeMVar done
 
       case status of
         -- readFd will take care of closing the fd
@@ -332,7 +291,7 @@ captureOutStreams action = do
                                  , _stdErr   = stderr'
                                  }
 
-        _ -> throwIO $ userError ("No such PID " ++ show pid)
+        _ -> throwIO $ userError $ ("No such PID " ++ show pid)
 
  where
   writeStds pout perr rout rerr = do
@@ -340,13 +299,13 @@ captureOutStreams action = do
     void
       $ forkIO
       $ hideError eofErrorType
-      $ flip EX.finally (putMVar doneOut ())
+      $ flip finally (putMVar doneOut ())
       $ readTilEOF (\x -> modifyIORef' rout (<> x)) pout
     doneErr <- newEmptyMVar
     void
       $ forkIO
       $ hideError eofErrorType
-      $ flip EX.finally (putMVar doneErr ())
+      $ flip finally (putMVar doneErr ())
       $ readTilEOF (\x -> modifyIORef' rerr (<> x)) perr
     takeMVar doneOut
     takeMVar doneErr
@@ -359,7 +318,7 @@ captureOutStreams action = do
 
 actionWithPipes :: ((Fd, Fd) -> IO b) -> IO b
 actionWithPipes a =
-  createPipe >>= \(p1, p2) -> flip finally (cleanup [p1, p2]) $ a (p1, p2)
+  createPipe >>= \(p1, p2) -> (flip finally) (cleanup [p1, p2]) $ a (p1, p2)
 
 cleanup :: [Fd] -> IO ()
 cleanup fds = for_ fds $ \fd -> handleIO (\_ -> pure ()) $ closeFd fd
@@ -392,13 +351,21 @@ toProcessError :: ByteString
                -> Maybe ProcessStatus
                -> Either ProcessError ()
 toProcessError exe args mps = case mps of
-  Just (SPPB.Exited (ExitFailure xi)) -> Left $ NonZeroExit xi exe args
+  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`.
@@ -420,32 +387,6 @@ searchPath paths needle = go paths
       else pure False
 
 
--- | Check wether a binary is shadowed by another one that comes before
--- it in PATH. Returns the path to said binary, if any.
-isShadowed :: Path Abs -> IO (Maybe (Path Abs))
-isShadowed p = do
-  let dir = dirname p
-  fn <- basename p
-  spaths <- catMaybes . fmap parseAbs <$> 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 :: Path Abs -> IO Bool
-isInPath p = do
-  let dir = dirname p
-  fn <- basename p
-  spaths <- catMaybes . fmap parseAbs <$> liftIO getSearchPath
-  if dir `elem` spaths
-  then isJust <$> searchPath [dir] fn
-  else pure False
-
-
 findFiles :: Path Abs -> Regex -> IO [Path Rel]
 findFiles path regex = do
   dirStream <- openDirStream (toFilePath path)
@@ -454,7 +395,7 @@ findFiles path regex = do
     . S.toList
     . S.filter (\(_, p) -> match regex p)
     $ dirContentsStream dirStream
-  pure $ parseRel =<< f
+  pure $ join $ fmap parseRel f
 
 
 findFiles' :: Path Abs -> MP.Parsec Void Text () -> IO [Path Rel]
@@ -467,28 +408,4 @@ findFiles' path parser = do
                              Left _ -> False
                              Right p' -> isJust $ MP.parseMaybe parser p')
     $ dirContentsStream dirStream
-  pure $ parseRel =<< f
+  pure $ join $ fmap parseRel f
-
-
-isBrokenSymlink :: Path Abs -> IO Bool
-isBrokenSymlink p =
-  handleIO
-      (\e -> if ioeGetErrorType e == NoSuchThing then pure True else throwIO e)
-    $ do
-        _ <- canonicalizePath p
-        pure False
-
-
-chmod_755 :: (MonadLogger m, MonadIO m) => Path a -> m ()
-chmod_755 (toFilePath -> 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

lib/GHCup/Utils/Logger.hs

@@ -1,24 +1,10 @@
-{-# 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 : POSIX
-
-Here we define our main logger.
--}
 module GHCup.Utils.Logger where
 
-import           GHCup.Types
 import           GHCup.Utils
 
 import           Control.Monad
-import           Control.Monad.IO.Class
-import           Control.Monad.Reader
 import           Control.Monad.Logger
 import           HPath
 import           HPath.IO
@@ -50,7 +36,7 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
           LevelOther t -> toLogStr "[ " <> toLogStr t <> toLogStr " ]"
     let out = fromLogStr (l <> toLogStr " " <> str' <> toLogStr "\n")
 
-    when (lcPrintDebug || (not lcPrintDebug && (level /= LevelDebug)))
+    when (lcPrintDebug || (lcPrintDebug == False && not (level == LevelDebug)))
       $ colorOutter out
 
     -- raw output
@@ -64,12 +50,11 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
     rawOutter outr
 
 
-initGHCupFileLogging :: (MonadIO m, MonadReader AppState m) => Path Rel -> m (Path Abs)
+initGHCupFileLogging :: Path Rel -> IO (Path Abs)
 initGHCupFileLogging context = do
-  AppState {dirs = Dirs {..}} <- ask
+  logs <- ghcupLogsDir
-  let logfile = logsDir </> context
+  let logfile = logs </> context
-  liftIO $ do
+  createDirIfMissing newDirPerms logs
-    createDirRecursive' logsDir
+  hideError doesNotExistErrorType $ deleteFile logfile
-    hideError doesNotExistErrorType $ deleteFile logfile
+  createRegularFile newFilePerms logfile
-    createRegularFile newFilePerms logfile
+  pure logfile
-    pure logfile

lib/GHCup/Utils/MegaParsec.hs

@@ -1,20 +1,12 @@
 {-# 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 : POSIX
--}
 module GHCup.Utils.MegaParsec where
 
 import           GHCup.Types
 
 import           Control.Applicative
+import           Control.Monad
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
 #endif
@@ -24,7 +16,6 @@ import           Data.Text                      ( Text )
 import           Data.Versions
 import           Data.Void
 
-import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T
 import qualified Text.Megaparsec               as MP
 
@@ -60,9 +51,9 @@ ghcTargetBinP :: Text -> MP.Parsec Void Text (Maybe Text, Text)
 ghcTargetBinP t =
   (,)
     <$> (   MP.try
-            (Just <$> parseUntil1 (MP.chunk "-" *> MP.chunk t) <* MP.chunk "-"
+            (Just <$> (parseUntil1 (MP.chunk "-" *> MP.chunk t)) <* MP.chunk "-"
             )
-        <|> ((\ _ x -> x) Nothing <$> mempty)
+        <|> (flip const Nothing <$> mempty)
         )
     <*> (MP.chunk t <* MP.eof)
 
@@ -73,38 +64,24 @@ ghcTargetBinP t =
 ghcTargetVerP :: MP.Parsec Void Text GHCTargetVersion
 ghcTargetVerP =
   (\x y -> GHCTargetVersion x y)
-    <$> (MP.try (Just <$> parseUntil1 (MP.chunk "-" *> verP') <* MP.chunk "-")
+    <$> (MP.try (Just <$> (parseUntil1 (MP.chunk "-" *> verP)) <* MP.chunk "-")
-        <|> ((\ _ x -> x) Nothing <$> mempty)
+        <|> (flip const Nothing <$> mempty)
         )
     <*> (version' <* MP.eof)
  where
-  verP' :: MP.Parsec Void Text Text
+  verP :: MP.Parsec Void Text Text
-  verP' = do
+  verP = do
     v <- version'
     let startsWithDigists =
           and
             . take 3
-            . concatMap
+            . join
-              (map
+            . (fmap . fmap)
                 (\case
                   (Digits _) -> True
                   (Str    _) -> False
-                ) . NE.toList)
+                )
-            . NE.toList
+            $ (_vChunks v)
-            $ _vChunks v
+    if startsWithDigists && not (isJust (_vEpoch 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

lib/GHCup/Utils/Prelude.hs

@@ -1,21 +1,13 @@
 {-# 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 : POSIX
-
-GHCup specific prelude. Lots of Excepts functionality.
--}
 module GHCup.Utils.Prelude where
 
 import           Control.Applicative
@@ -28,13 +20,11 @@ import           Data.ByteString                ( ByteString )
 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 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
@@ -128,7 +118,7 @@ lE' :: forall e' e es a m
     => (e' -> e)
     -> Either e' a
     -> Excepts es m a
-lE' f = liftE . veitherToExcepts . fromEither . first f
+lE' f = liftE . veitherToExcepts . fromEither . bimap f id
 
 lEM :: forall e es a m . (Monad m, e :< es) => m (Either e a) -> Excepts es m a
 lEM em = lift em >>= lE
@@ -138,7 +128,7 @@ lEM' :: forall e' e es a m
      => (e' -> e)
      -> m (Either e' a)
      -> Excepts es m a
-lEM' f em = lift em >>= lE . first f
+lEM' f em = lift em >>= lE . bimap f id
 
 fromEither :: Either a b -> VEither '[a] b
 fromEither = either (VLeft . V) VRight
@@ -175,11 +165,6 @@ liftIOException errType ex =
     . lift
 
 
--- | 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)
-
-
 hideErrorDef :: [IOErrorType] -> a -> IO a -> IO a
 hideErrorDef errs def =
   handleIO (\e -> if ioeGetErrorType e `elem` errs then pure def else ioError e)
@@ -197,8 +182,8 @@ hideExcept :: forall e es es' a m
            -> a
            -> Excepts es m a
            -> Excepts es' m a
-hideExcept _ a =
+hideExcept _ a action =
-  catchLiftLeft ((\_ -> pure a) :: (e -> Excepts es' m a))
+  catchLiftLeft ((\_ -> pure a) :: (e -> Excepts es' m a)) action
 
 
 hideExcept' :: forall e es es' m
@@ -206,8 +191,8 @@ hideExcept' :: forall e es es' m
             => e
             -> Excepts es m ()
             -> Excepts es' m ()
-hideExcept' _ =
+hideExcept' _ action =
-  catchLiftLeft ((\_ -> pure ()) :: (e -> Excepts es' m ()))
+  catchLiftLeft ((\_ -> pure ()) :: (e -> Excepts es' m ())) action
 
 
 reThrowAll :: forall e es es' a m
@@ -256,7 +241,7 @@ addToCurrentEnv :: MonadIO m
                 => [(ByteString, ByteString)]
                 -> m [(ByteString, ByteString)]
 addToCurrentEnv adds = do
-  cEnv <- liftIO getEnvironment
+  cEnv <- liftIO $ getEnvironment
   pure (adds ++ cEnv)
 
 
@@ -274,13 +259,3 @@ 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
-

lib/GHCup/Utils/String/QQ.hs

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

lib/GHCup/Version.hs

@@ -1,49 +1,22 @@
 {-# 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 : POSIX
--}
 module GHCup.Version where
 
-import           GHCup.Types
+import           GHCup.Utils.Version.QQ
-import           Paths_ghcup (version)
 
-import           Data.Version (Version(versionBranch))
+import           Data.Versions
-import           Data.Versions hiding (version)
 import           URI.ByteString
 import           URI.ByteString.QQ
 
-import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T
 
--- | This reflects the API version of the YAML.
+-- | This reflects the API version of the JSON.
 ghcupURL :: URI
-ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.4.yaml|]
+ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.2.json|]
 
--- | The current ghcup version.
 ghcUpVer :: PVP
-ghcUpVer = PVP . NE.fromList . fmap fromIntegral $ versionBranch version
+ghcUpVer = [pver|0.1.4|]
 
--- | 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/fish

@@ -1,19 +0,0 @@
- 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

@@ -1,32 +0,0 @@
-#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

@@ -1,54 +0,0 @@
-resolver: lts-17.4
-
-packages:
-  - .
-
-extra-deps:
-  - git: https://github.com/hasufell/text-conversions.git
-    commit: 9abf0e5e5664a3178367597c32db19880477a53c
-
-  - 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
-  - hpath-0.11.0@sha256:12b8405bee13d0007d644a888ef8407069ce7bbbd76970f8746b801447124ade,1440
-  - hpath-directory-0.14.1@sha256:548ac1321222c34caa843a41a2379a77d961141082a4695bb37cc4731e91b2c7,5312
-  - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
-  - hpath-io-0.14.1@sha256:d91373cd81483eb370a1c683e4add6182250dccce32f9b682bb1104f7765c750,1522
-  - hpath-posix-0.13.2@sha256:eec4ff2b00dc86be847aca0f409fc8f6212ffd2170ec36a17dc9a52b46562392,1615
-  - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
-  - 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
-  - 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
-
-  ghcup:
-    tui: true
-    internal-downloader: true
-
-system-ghc: true
-compiler: ghc-8.10.4
-compiler-check: match-exact
-
-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

@@ -1,198 +0,0 @@
-{-# 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           HPath
-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 (Path Rel) where
-  arbitrary =
-    either (error . show) id . parseRel . E.encodeUtf8 . T.pack
-      <$> listOf1 (elements ['a' .. 'z'])
-
-instance Arbitrary TarDir where
-  arbitrary = genericArbitrary
-  shrink    = genericShrink
-
-instance Arbitrary Tool 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

@@ -1,16 +0,0 @@
-{-# 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

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

test/MyLibTest.hs

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

test/Spec.hs

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

update-index-state.sh

@@ -0,0 +1,66 @@
+#!/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/ghcup.css

@@ -101,7 +101,6 @@ body#idx p.other-help {
 
 .instructions div.command-button {
 	display: flex;
-	align-items: center;
 }
 
 .instructions div.command-button button {
@@ -112,7 +111,7 @@ body#idx p.other-help {
 	border-style: solid;
 	border-radius: 3px;
 
-    margin-left: 0.5rem;
+    margin-left: 1rem;
     margin-right: auto;
 	margin-top: 25px;
 	margin-bottom: 25px;
@@ -135,21 +134,20 @@ hr {
 #platform-instructions-linux > div > pre,
 #platform-instructions-mac > div > pre,
 #platform-instructions-freebsd > div > pre,
-#platform-instructions-win32 > div > pre,
+#platform-instructions-win32 > pre,
-#platform-instructions-win64 > div > pre,
+#platform-instructions-win64 > pre,
 #platform-instructions-default > div > div > pre,
 #platform-instructions-unknown > div > div > pre {
     background-color: #515151;
     color: white;
     margin-left: auto;
+    margin-right: 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,

www/ghcup.js

@@ -149,17 +149,7 @@ function fill_in_bug_report_values() {
 }
 
 function copyToClipboard() {
-  const text = document.getElementById("ghcup-command-normal").innerText;
+  const text = document.getElementsByClassName("ghcup-command").item(0).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);

www/index.html

@@ -32,10 +32,7 @@
 
       <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'>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>
-		<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>
 
@@ -49,9 +46,6 @@
         <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 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">You appear to be running Windows 32-bit. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
       </div>
@@ -61,9 +55,6 @@
           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 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">You appear to be running Windows 64-bit. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
       </div>
 
@@ -86,7 +77,7 @@
 
         <!-- duplicate the default cross-platform instructions -->
         <div>
-          <p>If you are running Linux, macOS, FreeBSD or Windows Subsystem for Linux, run the following in your terminal (as a user other than root), then follow the onscreen instructions.</p>
+          <p>If you are running Linux, macOS or FreeBSD,<br/>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>
@@ -104,11 +95,9 @@
 
       <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, run the following
+          <p>To install Haskell, if you are running Linux, macOS or FreeBSD,<br/>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>
 
@@ -151,11 +140,9 @@
 
       <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, run the following
+          <p>To install Haskell, if you are running Linux, macOS or FreeBSD,<br/>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>