Allow for dynamic post-install, post-remove and pre-compile msgs

Also alerts if the binary is not in PATH at all.

Fixes #111

.gitlab-ci.yml

@@ -60,7 +60,7 @@ variables:
   script:
     - ./.gitlab/script/ghcup_version.sh
   variables:
-    JSON_VERSION: "0.0.3"
+    JSON_VERSION: "0.0.4"
   artifacts:
     expire_in: 2 week
     paths:
@@ -125,8 +125,8 @@ test:linux:bootstrap_script:
   script:
     - ./.gitlab/script/ghcup_bootstrap.sh
   variables:
-    GHC_VERSION: "8.8.4"
+    GHC_VERSION: "8.10.3"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
   extends:
     - .debian
 
@@ -135,14 +135,14 @@ test:linux:bootstrap_script:
 test:linux:recommended:
   extends: .test_ghcup_version:linux
   variables:
-    GHC_VERSION: "8.8.4"
+    GHC_VERSION: "8.10.3"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
 
 test:linux:latest:
   extends: .test_ghcup_version:linux
   variables:
-    GHC_VERSION: "8.10.2"
+    GHC_VERSION: "8.10.3"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
   allow_failure: true
 
 ######## linux 32bit test ########
@@ -150,7 +150,7 @@ test:linux:latest:
 test:linux:recommended:32bit:
   extends: .test_ghcup_version:linux32
   variables:
-    GHC_VERSION: "8.8.4"
+    GHC_VERSION: "8.10.2"
     CABAL_VERSION: "3.2.0.0"
 
 ######## darwin test ########
@@ -158,14 +158,14 @@ test:linux:recommended:32bit:
 test:mac:recommended:
   extends: .test_ghcup_version:darwin
   variables:
-    GHC_VERSION: "8.8.4"
+    GHC_VERSION: "8.10.3"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
 
 test:mac:latest:
   extends: .test_ghcup_version:darwin
   variables:
-    GHC_VERSION: "8.10.2"
+    GHC_VERSION: "8.10.3"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
   allow_failure: true
 
 
@@ -174,14 +174,14 @@ test:mac:latest:
 test:freebsd:recommended:
   extends: .test_ghcup_version:freebsd
   variables:
-    GHC_VERSION: "8.8.4"
+    GHC_VERSION: "8.10.3"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
 
 test:freebsd:latest:
   extends: .test_ghcup_version:freebsd
   variables:
-    GHC_VERSION: "8.10.2"
+    GHC_VERSION: "8.10.3"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
   allow_failure: true
 
 
@@ -195,8 +195,8 @@ release:linux:64bit:
     - ./.gitlab/before_script/linux/alpine/install_deps.sh
   variables:
     ARTIFACT: "x86_64-linux-ghcup"
-    GHC_VERSION: "8.8.4"
+    GHC_VERSION: "8.10.3"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
 
 
 release:linux:32bit:
@@ -207,7 +207,7 @@ release:linux:32bit:
     - ./.gitlab/before_script/linux/alpine/install_deps.sh
   variables:
     ARTIFACT: "i386-linux-ghcup"
-    GHC_VERSION: "8.8.4"
+    GHC_VERSION: "8.10.2"
     CABAL_VERSION: "3.2.0.0"
 
 
@@ -222,8 +222,8 @@ release:darwin:
     - ./.gitlab/before_script/darwin/install_deps.sh
   variables:
     ARTIFACT: "x86_64-apple-darwin-ghcup"
-    GHC_VERSION: "8.8.3"
+    GHC_VERSION: "8.10.3"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
     MACOSX_DEPLOYMENT_TARGET: "10.7"
 
 
@@ -238,6 +238,6 @@ release:freebsd:
     - ./.gitlab/before_script/freebsd/install_deps.sh
   variables:
     ARTIFACT: "x86_64-portbld-freebsd-ghcup"
-    GHC_VERSION: "8.8.3"
+    GHC_VERSION: "8.10.3"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
 

.gitlab/before_script/darwin/install_deps.sh

@@ -9,8 +9,9 @@ mkdir -p "${TMPDIR}"
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup > ./ghcup-bin
 chmod +x ghcup-bin
 
-./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin upgrade -i -f
-./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 
 exit 0

.gitlab/before_script/freebsd/install_deps.sh

@@ -11,8 +11,9 @@ mkdir -p "${TMPDIR}"
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-portbld-freebsd-ghcup > ./ghcup-bin
 chmod +x ghcup-bin
 
-./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin upgrade -i -f
-./ghcup-bin install-cabal ${CABAL_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 -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 
 exit 0

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

@@ -24,8 +24,9 @@ else
 	curl -sSfL https://downloads.haskell.org/ghcup/x86_64-linux-ghcup > ./ghcup-bin
 fi
 chmod +x ghcup-bin
-./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin upgrade -i -f
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 
 # utils
 apk add --no-cache \

.gitlab/before_script/linux/install_deps.sh

@@ -12,7 +12,8 @@ sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev li
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup > ./ghcup-bin
 chmod +x ghcup-bin
 
-./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin upgrade -i -f
-./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 

.gitlab/script/ghcup_release.sh

@@ -22,9 +22,9 @@ if [ "${OS}" = "LINUX" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
 	fi
 elif [ "${OS}" = "FREEBSD" ] ; then
-	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib static" -ftui
+	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib +static" -ftui
 else
-	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib static" --constraint="lzma static" -ftui
+	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib +static" --constraint="lzma +static" -ftui
 fi
 
 mkdir out

.travis/build.sh

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

CHANGELOG.md

@@ -1,13 +1,27 @@
 # Revision history for ghcup
 
-## 0.1.12 -- ????-??-??
+## 0.1.13 -- ????-??-??
 
+
+* 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 settings TUI hotkeys wrt #41
+* 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
 

HACKING.md

@@ -52,8 +52,19 @@ 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
+Download information on where to fetch bindists from is in the appropriate
-`GHCup.Data.GHCupDownloads`.
+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
 

README.md

@@ -119,9 +119,10 @@ To enable XDG style directories, set the environment variable `GHCUP_USE_XDG_DIR
 
 Then you can control the locations via XDG environment variables as such:
 
-* `XDG_DATA_HOME`: GHCs will be unpacked in `ghcup/ghc` subdir
+* `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
+* `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`)
 
 ### Installing custom bindists
 

app/ghcup-gen/Main.hs

@@ -14,6 +14,7 @@ import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.Logger
 
+import           Data.Char                      ( toLower )
 #if !MIN_VERSION_base(4,13,0)
 import           Data.Semigroup                 ( (<>) )
 #endif
@@ -21,6 +22,7 @@ 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
@@ -32,7 +34,7 @@ data Options = Options
   }
 
 data Command = ValidateYAML ValidateYAMLOpts
-             | ValidateTarballs ValidateYAMLOpts
+             | ValidateTarballs ValidateYAMLOpts TarballFilter
 
 
 data Input
@@ -63,6 +65,22 @@ data ValidateYAMLOpts = ValidateYAMLOpts
 validateYAMLOpts :: Parser ValidateYAMLOpts
 validateYAMLOpts = ValidateYAMLOpts <$> optional inputP
 
+tarballFilterP :: Parser TarballFilter
+tarballFilterP = option readm $
+  long "tarball-filter" <> short 'u' <> metavar "<tool>-<version>" <> value def
+    <> help "Only check certain tarballs (format: <tool>-<version>)"
+  where
+    def = TarballFilter Nothing (makeRegex ("" :: String))
+    readm = do
+      s <- str
+      case span (/= '-') s of
+        (_, []) -> fail "invalid format, missing '-' after the tool name"
+        (t, v) | [tool] <- [ tool | tool <- [minBound..maxBound], low (show tool) == low t ] ->
+          TarballFilter <$> pure (Just tool) <*> makeRegexOptsM compIgnoreCase execBlank (drop 1 v)
+        _ -> fail "invalid tool"
+    low = fmap toLower
+
+
 opts :: Parser Options
 opts = Options <$> com
 
@@ -78,11 +96,9 @@ com = subparser
      )
   <> (command
        "check-tarballs"
-       (   ValidateTarballs
+       (info
-       <$> (info
+         ((ValidateTarballs <$> validateYAMLOpts <*> tarballFilterP) <**> helper)
-             (validateYAMLOpts <**> helper)
+         (progDesc "Validate all tarballs (download and checksum)")
-             (progDesc "Validate all tarballs (download and checksum)")
-           )
        )
      )
   )
@@ -100,13 +116,13 @@ main = do
               B.getContents >>= valAndExit validate
             ValidateYAMLOpts { vInput = Just (FileInput file) } ->
               B.readFile file >>= valAndExit validate
-          ValidateTarballs vopts -> case vopts of
+          ValidateTarballs vopts tarballFilter -> case vopts of
             ValidateYAMLOpts { vInput = Nothing } ->
-              B.getContents >>= valAndExit validateTarballs
+              B.getContents >>= valAndExit (validateTarballs tarballFilter)
             ValidateYAMLOpts { vInput = Just StdInput } ->
-              B.getContents >>= valAndExit validateTarballs
+              B.getContents >>= valAndExit (validateTarballs tarballFilter)
             ValidateYAMLOpts { vInput = Just (FileInput file) } ->
-              B.readFile file >>= valAndExit validateTarballs
+              B.readFile file >>= valAndExit (validateTarballs tarballFilter)
   pure ()
 
  where

app/ghcup-gen/Validate.hs

@@ -7,6 +7,7 @@ module Validate where
 import           GHCup
 import           GHCup.Download
 import           GHCup.Types
+import           GHCup.Types.Optics
 import           GHCup.Utils.Dirs
 import           GHCup.Utils.Logger
 import           GHCup.Utils.Version.QQ
@@ -21,6 +22,7 @@ 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
@@ -30,6 +32,7 @@ import           Optics
 import           System.Exit
 import           System.IO
 import           Text.ParserCombinators.ReadP
+import           Text.Regex.Posix
 
 import qualified Data.ByteString               as B
 import qualified Data.Map.Strict               as M
@@ -64,7 +67,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 arch (M.keys pspecs)
+          checkHasRequiredPlatforms t v (_viTags vi) arch (M.keys pspecs)
 
     checkGHCVerIsValid
     forM_ (M.toList dls) $ \(t, _) -> checkMandatoryTags t
@@ -78,17 +81,18 @@ validate dls = do
         lift $ $(logInfo) [i|All good|]
         pure ExitSuccess
  where
-  checkHasRequiredPlatforms t v arch pspecs = do
+  checkHasRequiredPlatforms t v tags arch pspecs = do
     let v' = prettyVer v
+        arch' = prettyArch arch
     when (not $ any (== Linux UnknownLinux) pspecs) $ do
       lift $ $(logError)
-        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch}|]
+        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch'}|]
       addError
     when ((not $ any (== Darwin) pspecs) && arch == A_64) $ do
-      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch}|]
+      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch'}|]
       addError
     when ((not $ any (== FreeBSD) pspecs) && arch == A_64) $ lift $ $(logWarn)
-      [i|FreeBSD missing for #{t} #{v'} #{arch}|]
+      [i|FreeBSD missing for #{t} #{v'} #{arch'}|]
 
     -- alpine needs to be set explicitly, because
     -- we cannot assume that "Linux UnknownLinux" runs on Alpine
@@ -96,8 +100,9 @@ validate dls = do
     when (not $ any (== Linux Alpine) pspecs) $
       case t of
         GHCup -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
-        Cabal | v > [vver|2.4.1.0|] -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
+        Cabal | v > [vver|2.4.1.0|] -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]) >> addError
-        _     -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]
+        GHC | Latest `elem` tags || Recommended `elem` tags -> 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
@@ -157,6 +162,11 @@ validate dls = do
   isBase (Base _) = True
   isBase _        = False
 
+data TarballFilter = TarballFilter
+  { tfTool    :: Maybe Tool
+  , tfVersion :: Regex
+  }
+
 validateTarballs :: ( Monad m
                     , MonadLogger m
                     , MonadThrow m
@@ -164,23 +174,20 @@ validateTarballs :: ( Monad m
                     , MonadUnliftIO m
                     , MonadMask m
                     )
-                 => GHCupDownloads
+                 => TarballFilter
+                 -> GHCupDownloads
                  -> m ExitCode
-validateTarballs dls = do
+validateTarballs (TarballFilter tool versionRegex) dls = do
   ref <- liftIO $ newIORef 0
 
   flip runReaderT ref $ do
-     -- download/verify all binary tarballs
+     -- download/verify all tarballs
-    let
+    let dlis = nubOrd $ dls ^.. each
-      dlbis = nub $ join $ (M.elems dls) <&> \versions ->
+          %& indices (maybe (const True) (==) tool) %> each
-        join $ (M.elems versions) <&> \vi ->
+          %& indices (matchTest versionRegex . T.unpack . prettyVer)
-          join $ (M.elems $ _viArch vi) <&> \pspecs ->
+          % (viSourceDL % _Just `summing` viArch % each % each % each)
-            join $ (M.elems pspecs) <&> \pverspecs -> (M.elems pverspecs)
+    when (null dlis) $ $(logError) [i|no tarballs selected by filter|] *> addError
-    forM_ dlbis $ downloadAll
+    forM_ dlis $ downloadAll
-
-    let dlsrc = nub $ join $ (M.elems dls) <&> \versions ->
-          join $ (M.elems versions) <&> maybe [] (: []) . _viSourceDL
-    forM_ dlsrc $ downloadAll
 
     -- exit
     e <- liftIO $ readIORef ref
@@ -191,13 +198,13 @@ validateTarballs dls = do
         pure ExitSuccess
 
  where
+  runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
+                                     , colorOutter  = B.hPut stderr
+                                     , rawOutter    = (\_ -> pure ())
+                                     }
   downloadAll dli = do
     dirs <- liftIO getDirs
     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

app/ghcup/BrickMain.hs

@@ -16,6 +16,7 @@ import           GHCup.Types
 import           GHCup.Utils
 import           GHCup.Utils.File
 import           GHCup.Utils.Logger
+import           GHCup.Utils.Prelude     hiding ((!?))
 
 import           Brick
 import           Brick.Widgets.Border
@@ -44,10 +45,13 @@ 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           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
@@ -116,8 +120,8 @@ showKey (Vty.KDown) = "↓"
 showKey key = tail (show key)
 
 
-ui :: BrickState -> Widget String
+ui :: AttrMap -> BrickState -> Widget String
-ui BrickState { appSettings = as@(BrickSettings {}), ..}
+ui dimAttrs BrickState { appSettings = as@(BrickSettings {}), ..}
   = ( padBottom Max
     $ ( withBorderStyle unicode
       $ borderWithLabel (str "GHCup")
@@ -148,9 +152,9 @@ ui BrickState { appSettings = as@(BrickSettings {}), ..}
         ver = case lCross of
           Nothing -> T.unpack . prettyVer $ lVer
           Just c  -> T.unpack (c <> "-" <> prettyVer lVer)
-        dim = if lNoBindist
+        dim
-          then updateAttrMap (const dimAttributes) . withAttr "no-bindist"
+          | lNoBindist = updateAttrMap (const dimAttrs) . withAttr "no-bindist"
-          else id
+          | otherwise  = id
         hooray
           | elem Latest lTag && not lInstalled =
               withAttr "hooray"
@@ -237,39 +241,49 @@ minHSize :: Int -> Widget n -> Widget n
 minHSize s' = hLimit s' . vLimit 1 . (<+> fill ' ')
 
 
-app :: App BrickState e String
+app :: AttrMap -> AttrMap -> App BrickState e String
-app = App { appDraw         = \st -> [ui st]
+app attrs dimAttrs =
-          , appHandleEvent  = eventHandler
+  App { appDraw         = \st -> [ui dimAttrs st]
-          , appStartEvent   = return
+  , appHandleEvent  = eventHandler
-          , appAttrMap      = const defaultAttributes
+  , appStartEvent   = return
-          , appChooseCursor = neverShowCursor
+  , appAttrMap      = const attrs
-          }
+  , appChooseCursor = neverShowCursor
+  }
 
-defaultAttributes :: AttrMap
+defaultAttributes :: Bool -> AttrMap
-defaultAttributes = attrMap
+defaultAttributes no_color = attrMap
   Vty.defAttr
-  [ ("active"       , Vty.defAttr `Vty.withBackColor` Vty.blue)
+  [ ("active"       , Vty.defAttr `withBackColor` Vty.blue)
-  , ("not-installed", Vty.defAttr `Vty.withForeColor` Vty.red)
+  , ("not-installed", Vty.defAttr `withForeColor` Vty.red)
-  , ("set"          , Vty.defAttr `Vty.withForeColor` Vty.green)
+  , ("set"          , Vty.defAttr `withForeColor` Vty.green)
-  , ("installed"    , Vty.defAttr `Vty.withForeColor` Vty.green)
+  , ("installed"    , Vty.defAttr `withForeColor` Vty.green)
-  , ("recommended"  , Vty.defAttr `Vty.withForeColor` Vty.green)
+  , ("recommended"  , Vty.defAttr `withForeColor` Vty.green)
-  , ("hls-powered"  , Vty.defAttr `Vty.withForeColor` Vty.green)
+  , ("hls-powered"  , Vty.defAttr `withForeColor` Vty.green)
-  , ("latest"       , Vty.defAttr `Vty.withForeColor` Vty.yellow)
+  , ("latest"       , Vty.defAttr `withForeColor` Vty.yellow)
-  , ("prerelease"   , Vty.defAttr `Vty.withForeColor` Vty.red)
+  , ("prerelease"   , Vty.defAttr `withForeColor` Vty.red)
-  , ("compiled"     , Vty.defAttr `Vty.withForeColor` Vty.blue)
+  , ("compiled"     , Vty.defAttr `withForeColor` Vty.blue)
-  , ("stray"        , Vty.defAttr `Vty.withForeColor` Vty.blue)
+  , ("stray"        , Vty.defAttr `withForeColor` Vty.blue)
-  , ("help"         , Vty.defAttr `Vty.withStyle` Vty.italic)
+  , ("help"         , Vty.defAttr `withStyle`     Vty.italic)
-  , ("hooray"       , Vty.defAttr `Vty.withForeColor` Vty.brightWhite)
+  , ("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
 
-dimAttributes :: AttrMap
+    withStyle                 = Vty.withStyle
-dimAttributes = attrMap
+
+dimAttributes :: Bool -> AttrMap
+dimAttributes no_color = attrMap
   (Vty.defAttr `Vty.withStyle` Vty.dim)
-  [ ("active"    , Vty.defAttr `Vty.withBackColor` Vty.blue)
+  [ ("active"    , Vty.defAttr `withBackColor` Vty.blue)
   , ("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
@@ -401,17 +415,32 @@ install' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
               , DownloadFailed
               , NoUpdate
               , TarDirDoesNotExist
+              , VerNotFound
               ]
 
   (run $ do
       case lTool of
-        GHC   -> liftE $ installGHCBin dls lVer pfreq
+        GHC   -> do
-        Cabal -> liftE $ installCabalBin dls lVer pfreq
+          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer GHC dls
-        GHCup -> liftE $ upgradeGHCup dls Nothing False pfreq $> ()
+            ?? VerNotFound lVer GHC
-        HLS   -> liftE $ installHLSBin dls lVer pfreq $> ()
+          liftE $ installGHCBin dls lVer pfreq $> vi
+        Cabal -> do
+          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer Cabal dls
+            ?? VerNotFound lVer Cabal
+          liftE $ installCabalBin dls lVer pfreq $> vi
+        GHCup -> do
+          let vi = fromJust $ snd <$> getLatest dls GHCup
+          liftE $ upgradeGHCup dls Nothing False pfreq $> vi
+        HLS   -> do
+          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer HLS dls
+            ?? VerNotFound lVer HLS
+          liftE $ installHLSBin dls lVer pfreq $> vi
     )
     >>= \case
-          VRight _                          -> pure $ Right ()
+          VRight vi                         -> do
+            forM_ (_viPostInstall vi) $ \msg ->
+              runLogger $ $(logInfo) msg
+            pure $ Right ()
           VLeft  (V (AlreadyInstalled _ _)) -> pure $ Right ()
           VLeft (V (BuildFailed _ e)) ->
             pure $ Left [i|Build failed with #{e}|]
@@ -446,21 +475,34 @@ set' _ (_, ListResult {..}) = do
 
 
 del' :: BrickState -> (Int, ListResult) -> IO (Either String ())
-del' _ (_, ListResult {..}) = do
+del' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
   settings <- readIORef settings'
   l        <- readIORef logger'
   let runLogger = myLoggerT l
 
-  let run = runLogger . flip runReaderT settings . runE @'[NotInstalled]
+  let run = runLogger . flip runReaderT settings . runE @'[NotInstalled, VerNotFound]
 
   (run $ do
       case lTool of
-        GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> ()
+        GHC   -> do
-        Cabal -> liftE $ rmCabalVer lVer $> ()
+          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer Cabal dls
-        HLS   -> liftE $ rmHLSVer lVer $> ()
+            ?? VerNotFound lVer Cabal
-        GHCup -> pure ()
+          liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> Just vi
+        Cabal -> do
+          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer Cabal dls
+            ?? VerNotFound lVer Cabal
+          liftE $ rmCabalVer lVer $> Just vi
+        HLS   -> do
+          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer Cabal dls
+            ?? VerNotFound lVer Cabal
+          liftE $ rmHLSVer lVer $> Just vi
+        GHCup -> pure Nothing
     )
     >>= \case
+          VRight (Just vi) -> do
+            forM_ (_viPostRemove vi) $ \msg ->
+              runLogger $ $(logInfo) msg
+            pure $ Right ()
           VRight _ -> pure $ Right ()
           VLeft  e -> pure $ Left [i|#{e}|]
 
@@ -480,11 +522,6 @@ changelog' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
         Left  e -> pure $ Left [i|#{e}|]
 
 
-uri' :: IORef (Maybe URI)
-{-# NOINLINE uri' #-}
-uri' = unsafePerformIO (newIORef Nothing)
-
-
 settings' :: IORef AppState
 {-# NOINLINE settings' #-}
 settings' = unsafePerformIO $ do
@@ -513,23 +550,23 @@ logger' = unsafePerformIO
 
 
 brickMain :: AppState
-          -> Maybe URI
           -> LoggerConfig
           -> GHCupDownloads
           -> PlatformRequest
           -> IO ()
-brickMain s muri l av pfreq' = do
+brickMain s l av pfreq' = do
-  writeIORef uri'      muri
   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
+          (app (defaultAttributes no_color) (dimAttributes no_color))
           (BrickState ad
                     defaultAppSettings
                     (constructList ad defaultAppSettings Nothing)
@@ -548,7 +585,6 @@ defaultAppSettings = BrickSettings { showAll = False }
 
 getDownloads' :: IO (Either String GHCupDownloads)
 getDownloads' = do
-  muri     <- readIORef uri'
   settings <- readIORef settings'
   l        <- readIORef logger'
   let runLogger = myLoggerT l
@@ -559,7 +595,7 @@ getDownloads' = do
     . runE @'[JSONError , DownloadFailed , FileDoesNotExistError]
     $ fmap _ghcupDownloads
     $ liftE
-    $ getDownloadsF (maybe GHCupURL OwnSource muri)
+    $ getDownloadsF (urlSource . GT.settings $ settings)
 
   case r of
     VRight a -> pure $ Right a

app/ghcup/Main.hs

@@ -32,6 +32,7 @@ import           GHCup.Version
 #if !defined(TAR)
 import           Codec.Archive
 #endif
+import           Control.Concurrent
 import           Control.Exception.Safe
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
@@ -59,7 +60,8 @@ import           Options.Applicative     hiding ( style )
 import           Options.Applicative.Help.Pretty ( text )
 import           Prelude                 hiding ( appendFile )
 import           Safe
-import           System.Console.Pretty
+import           System.Console.Pretty   hiding ( color )
+import qualified System.Console.Pretty         as Pretty
 import           System.Environment
 import           System.Exit
 import           System.IO               hiding ( appendFile )
@@ -752,9 +754,9 @@ cabalCompileOpts =
 
 
 toolVersionParser :: Parser ToolVersion
-toolVersionParser = verP <|> toolP
+toolVersionParser = verP' <|> toolP
  where
-  verP = ToolVersion <$> versionParser
+  verP' = ToolVersion <$> versionParser
   toolP =
     ToolTag
       <$> (option
@@ -882,17 +884,6 @@ platformParser s' = case MP.parse (platformP <* MP.eof) "" (T.pack s') of
     , MP.chunk "exherbo" $> Exherbo
     , MP.chunk "unknown" $> UnknownLinux
     ]
-  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
 
 
 bindistParser :: String -> Either String URI
@@ -1050,6 +1041,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                       , NotInstalled
                       , BuildFailed
                       , TagNotFound
+                      , VerNotFound
                       , DigestError
                       , DownloadFailed
                       , TarDirDoesNotExist
@@ -1065,6 +1057,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                   @'[ FileDoesNotExistError
                     , NotInstalled
                     , TagNotFound
+                    , VerNotFound
                     ]
 
           let
@@ -1074,6 +1067,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                 . runE
                   @'[ NotInstalled
                     , TagNotFound
+                    , VerNotFound
                     ]
 
           let
@@ -1083,12 +1077,13 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                 . runE
                   @'[ NotInstalled
                     , TagNotFound
+                    , VerNotFound
                     ]
 
           let runListGHC = runLogger . flip runReaderT appstate
 
           let runRm =
-                runLogger . flip runReaderT appstate . runE @'[NotInstalled]
+                runLogger . flip runReaderT appstate . runE @'[NotInstalled, VerNotFound]
 
           let runDebugInfo =
                 runLogger
@@ -1112,6 +1107,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                       , UnknownArchive
                       , TarDirDoesNotExist
                       , NotInstalled
+                      , VerNotFound
 #if !defined(TAR)
                       , ArchiveResult
 #endif
@@ -1172,24 +1168,28 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
           let installGHC InstallOptions{..} =
                   (case instBindist of
                      Nothing -> runInstTool $ do
-                       v <- liftE $ fromVersion dls instVer GHC
+                       (v, vi) <- liftE $ fromVersion dls instVer GHC
                        liftE $ installGHCBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
                        when instSet $ void $ liftE $ setGHC v SetGHCOnly
+                       pure vi
                      Just uri -> runInstTool' appstate{ settings = settings {noVerify = True}} $ do
-                       v <- liftE $ fromVersion dls instVer GHC
+                       (v, vi) <- liftE $ fromVersion dls instVer GHC
                        liftE $ installGHCBindist
                          (DownloadInfo uri (Just $ RegexDir "ghc-.*") "")
                          (_tvVersion v)
                          (fromMaybe pfreq instPlatform)
                        when instSet $ void $ liftE $ setGHC v SetGHCOnly
+                       pure vi
                     )
                     >>= \case
-                          VRight _ -> do
+                          VRight vi -> do
                             runLogger $ $(logInfo) ("GHC installation successful")
+                            forM_ (_viPostInstall vi) $ \msg ->
+                              runLogger $ $(logInfo) msg
                             pure ExitSuccess
                           VLeft (V (AlreadyInstalled _ v)) -> do
                             runLogger $ $(logWarn)
-                              [i|GHC ver #{prettyVer v} already installed, you may want to run 'ghcup rm ghc #{prettyVer v}' first|]
+                              [i|GHC ver #{prettyVer v} already installed; if you really want to reinstall it, you may want to run 'ghcup rm ghc #{prettyVer v}' first|]
                             pure ExitSuccess
                           VLeft (V (BuildFailed tmpdir e)) -> do
                             case keepDirs settings of
@@ -1215,22 +1215,26 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
           let installCabal InstallOptions{..} =
                 (case instBindist of
                    Nothing -> runInstTool $ do
-                     v <- liftE $ fromVersion dls instVer Cabal
+                     (v, vi) <- liftE $ fromVersion dls instVer Cabal
                      liftE $ installCabalBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
+                     pure vi
                    Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} $ do
-                     v <- liftE $ fromVersion dls instVer Cabal
+                     (v, vi) <- liftE $ fromVersion dls instVer Cabal
                      liftE $ installCabalBindist
                          (DownloadInfo uri Nothing "")
                          (_tvVersion v)
                          (fromMaybe pfreq instPlatform)
+                     pure vi
                   )
                   >>= \case
-                        VRight _ -> do
+                        VRight vi -> do
                           runLogger $ $(logInfo) ("Cabal installation successful")
+                          forM_ (_viPostInstall vi) $ \msg ->
+                            runLogger $ $(logInfo) msg
                           pure ExitSuccess
                         VLeft (V (AlreadyInstalled _ v)) -> do
                           runLogger $ $(logWarn)
-                            [i|Cabal ver #{prettyVer v} already installed, you may want to run 'ghcup rm cabal #{prettyVer v}' first|]
+                            [i|Cabal ver #{prettyVer v} already installed; if you really want to reinstall it, you may want to run 'ghcup rm cabal #{prettyVer v}' first|]
                           pure ExitSuccess
                         VLeft (V NoDownload) -> do
 
@@ -1248,22 +1252,26 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
           let installHLS InstallOptions{..} =
                 (case instBindist of
                    Nothing -> runInstTool $ do
-                     v <- liftE $ fromVersion dls instVer HLS
+                     (v, vi) <- liftE $ fromVersion dls instVer HLS
                      liftE $ installHLSBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
+                     pure vi
                    Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} $ do
-                     v <- liftE $ fromVersion dls instVer HLS
+                     (v, vi) <- liftE $ fromVersion dls instVer HLS
                      liftE $ installHLSBindist
                          (DownloadInfo uri Nothing "")
                          (_tvVersion v)
                          (fromMaybe pfreq instPlatform)
+                     pure vi
                   )
                   >>= \case
-                        VRight _ -> do
+                        VRight vi -> do
                           runLogger $ $(logInfo) ("HLS installation successful")
+                          forM_ (_viPostInstall vi) $ \msg ->
+                            runLogger $ $(logInfo) msg
                           pure ExitSuccess
                         VLeft (V (AlreadyInstalled _ v)) -> do
                           runLogger $ $(logWarn)
-                            [i|HLS ver #{prettyVer v} already installed, you may want to run 'ghcup rm hls #{prettyVer v}' first|]
+                            [i|HLS ver #{prettyVer v} already installed; if you really want to reinstall it, you may want to run 'ghcup rm hls #{prettyVer v}' first|]
                           pure ExitSuccess
                         VLeft (V NoDownload) -> do
 
@@ -1281,7 +1289,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
           let setGHC' SetOptions{..} =
                 (runSetGHC $ do
-                    v <- liftE $ fromVersion dls sToolVer GHC
+                    v <- liftE $ fst <$> fromVersion dls sToolVer GHC
                     liftE $ setGHC v SetGHCOnly
                   )
                   >>= \case
@@ -1296,7 +1304,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
           let setCabal' SetOptions{..} =
                 (runSetCabal $ do
-                    v <- liftE $ fromVersion dls sToolVer Cabal
+                    v <- liftE $ fst <$> fromVersion dls sToolVer Cabal
                     liftE $ setCabal (_tvVersion v)
                   )
                   >>= \case
@@ -1307,7 +1315,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
           let setHLS' SetOptions{..} =
                 (runSetHLS $ do
-                    v <- liftE $ fromVersion dls sToolVer HLS
+                    v <- liftE $ fst <$> fromVersion dls sToolVer HLS
                     liftE $ setHLS (_tvVersion v)
                   )
                   >>= \case
@@ -1318,30 +1326,51 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
           let rmGHC' RmOptions{..} =
                 (runRm $ do
-                    liftE $ rmGHCVer ghcVer
+                    liftE $
+                      rmGHCVer ghcVer
+                    vi <- liftE @_ @'[VerNotFound] $ getVersionInfo (_tvVersion ghcVer) GHC dls
+                      ?? VerNotFound (_tvVersion ghcVer) GHC
+                    pure vi
                   )
                   >>= \case
-                        VRight _ -> pure ExitSuccess
+                        VRight vi -> do
+                          forM_ (_viPostRemove vi) $ \msg ->
+                            runLogger $ $(logInfo) msg
+                          pure ExitSuccess
                         VLeft  e -> do
                           runLogger ($(logError) [i|#{e}|])
                           pure $ ExitFailure 7
 
           let rmCabal' tv =
                 (runRm $ do
-                    liftE $ rmCabalVer tv
+                    liftE $
+                      rmCabalVer tv
+                    vi <- liftE @_ @'[VerNotFound] $ getVersionInfo tv Cabal dls
+                      ?? VerNotFound tv Cabal
+                    pure vi
                   )
                   >>= \case
-                        VRight _ -> pure ExitSuccess
+                        VRight vi -> do
+                          forM_ (_viPostRemove vi) $ \msg ->
+                            runLogger $ $(logInfo) msg
+                          pure ExitSuccess
                         VLeft  e -> do
                           runLogger ($(logError) [i|#{e}|])
                           pure $ ExitFailure 15
 
           let rmHLS' tv =
                 (runRm $ do
-                    liftE $ rmHLSVer tv
+                    liftE $
+                      rmHLSVer tv
+                    vi <- liftE @_ @'[VerNotFound] $ getVersionInfo tv HLS dls
+                      ?? VerNotFound tv HLS
+                    pure vi
                   )
                   >>= \case
-                        VRight _ -> pure ExitSuccess
+                        VRight vi -> do
+                          forM_ (_viPostRemove vi) $ \msg ->
+                            runLogger $ $(logInfo) msg
+                          pure ExitSuccess
                         VLeft  e -> do
                           runLogger ($(logError) [i|#{e}|])
                           pure $ ExitFailure 15
@@ -1349,7 +1378,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
           res <- case optCommand of
 #if defined(BRICK)
-            Interactive -> liftIO $ brickMain appstate optUrlSource loggerConfig dls pfreq >> pure ExitSuccess
+            Interactive -> liftIO $ brickMain appstate loggerConfig dls pfreq >> pure ExitSuccess
 #endif
             Install (Right iopts) -> do
               runLogger ($(logWarn) [i|This is an old-style command for installing GHC. Use 'ghcup install ghc' instead.|])
@@ -1395,6 +1424,13 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
             Compile (CompileGHC GHCCompileOptions {..}) ->
               (runCompileGHC $ do
+                vi <- liftE @_ @'[VerNotFound] $ getVersionInfo targetVer GHC dls
+                  ?? VerNotFound targetVer GHC
+                forM_ (_viPreCompile vi) $ \msg -> do
+                  lift $ $(logInfo) msg
+                  lift $ $(logInfo)
+                    ("...waiting for 5 seconds, you can still abort...")
+                  liftIO $ threadDelay 5000000 -- for compilation, give the user a sec to intervene
                 liftE $ compileGHC dls
                             (GHCTargetVersion crossTarget targetVer)
                             bootstrapGhc
@@ -1403,17 +1439,20 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                             patchDir
                             addConfArgs
                             pfreq
-                when setCompile $ void $ liftE
+                when setCompile $ void $ liftE $
-                  $ setGHC (GHCTargetVersion crossTarget targetVer) SetGHCOnly
+                  setGHC (GHCTargetVersion crossTarget targetVer) SetGHCOnly
+                pure vi
                 )
                 >>= \case
-                      VRight _ -> do
+                      VRight vi -> do
                         runLogger $ $(logInfo)
                           ("GHC successfully compiled and installed")
+                        forM_ (_viPostInstall vi) $ \msg ->
+                          runLogger $ $(logInfo) msg
                         pure ExitSuccess
                       VLeft (V (AlreadyInstalled _ v)) -> do
                         runLogger $ $(logWarn)
-                          [i|GHC ver #{prettyVer v} already installed, you may want to run 'ghcup rm ghc #{prettyVer v}' first|]
+                          [i|GHC ver #{prettyVer v} already installed; if you really want to reinstall it, you may want to run 'ghcup rm ghc #{prettyVer v}' first|]
                         pure ExitSuccess
                       VLeft (V (BuildFailed tmpdir e)) -> do
                         case keepDirs settings of
@@ -1439,8 +1478,11 @@ Make sure to clean up #{tmpdir} afterwards.|])
               (runUpgrade $ (liftE $ upgradeGHCup dls target force pfreq)) >>= \case
                 VRight v' -> do
                   let pretty_v = prettyVer v'
+                  let vi = fromJust $ snd <$> getLatest dls GHCup
                   runLogger $ $(logInfo)
                     [i|Successfully upgraded GHCup to version #{pretty_v}|]
+                  forM_ (_viPostInstall vi) $ \msg ->
+                    runLogger $ $(logInfo) msg
                   pure ExitSuccess
                 VLeft (V NoUpdate) -> do
                   runLogger $ $(logWarn) [i|No GHCup update available|]
@@ -1516,23 +1558,25 @@ fromVersion :: Monad m
             => GHCupDownloads
             -> Maybe ToolVersion
             -> Tool
-            -> Excepts '[TagNotFound] m GHCTargetVersion
+            -> Excepts '[TagNotFound, VerNotFound] m (GHCTargetVersion, VersionInfo)
 fromVersion av Nothing tool =
-  mkTVer <$> getRecommended av tool ?? TagNotFound Recommended tool
+  (\(x, y) -> (mkTVer x, y)) <$> getRecommended av tool
-fromVersion av (Just (ToolVersion v)) _ = do
+    ?? TagNotFound Recommended tool
+fromVersion av (Just (ToolVersion v)) tool = do
+  vi <- getVersionInfo (_tvVersion v) tool av ?? VerNotFound (_tvVersion v) tool
   case pvp $ prettyVer (_tvVersion v) of
-    Left _ -> pure v
+    Left _ -> pure (v, vi)
     Right (PVP (major' :|[minor'])) ->
       case getLatestGHCFor (fromIntegral major') (fromIntegral minor') av of
-        Just v' -> pure $ GHCTargetVersion (_tvTarget v) v'
+        Just (v', vi') -> pure (GHCTargetVersion (_tvTarget v) v', vi')
-        Nothing -> pure v
+        Nothing -> pure (v, vi)
-    Right _ -> pure v
+    Right _ -> pure (v, vi)
 fromVersion av (Just (ToolTag Latest)) tool =
-  mkTVer <$> getLatest av tool ?? TagNotFound Latest tool
+  (\(x, y) -> (mkTVer x, y)) <$> getLatest av tool ?? TagNotFound Latest tool
 fromVersion av (Just (ToolTag Recommended)) tool =
-  mkTVer <$> getRecommended av tool ?? TagNotFound Recommended tool
+  (\(x, y) -> (mkTVer x, y)) <$> getRecommended av tool ?? TagNotFound Recommended tool
 fromVersion av (Just (ToolTag (Base pvp''))) GHC =
-  mkTVer <$> getLatestBaseVersion av pvp'' ?? TagNotFound (Base pvp'') GHC
+  (\(x, y) -> (mkTVer x, y)) <$> getLatestBaseVersion av pvp'' ?? TagNotFound (Base pvp'') GHC
 fromVersion _ (Just (ToolTag t')) tool =
   throwE $ TagNotFound t' tool
 
@@ -1542,6 +1586,20 @@ printListResult raw lr = do
   -- https://gitlab.haskell.org/ghc/ghc/issues/8118
   setLocaleEncoding utf8
 
+  no_color <- isJust <$> lookupEnv "NO_COLOR"
+
+  let
+    color | raw || no_color = flip const
+          | otherwise       = Pretty.color
+
+  let
+    printTag Recommended        = color Green "recommended"
+    printTag Latest             = color Yellow "latest"
+    printTag Prerelease         = color Red "prerelease"
+    printTag (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
+    printTag (UnknownTag t    ) = t
+    printTag Old                = ""
+
   let
     rows =
       (\x -> if raw
@@ -1563,13 +1621,13 @@ printListResult raw lr = do
                      , intercalate "," $ (filter (/= "") . fmap printTag $ sort lTag)
                      , intercalate ","
                      $  (if hlsPowered
-                          then [color' Green "hls-powered"]
+                          then [color Green "hls-powered"]
                           else mempty
                         )
-                     ++ (if fromSrc then [color' Blue "compiled"] else mempty)
+                     ++ (if fromSrc then [color Blue "compiled"] else mempty)
-                     ++ (if lStray then [color' Yellow "stray"] else mempty)
+                     ++ (if lStray then [color Yellow "stray"] else mempty)
                      ++ (if lNoBindist
-                          then [color' Red "no-bindist"]
+                          then [color Red "no-bindist"]
                           else mempty
                         )
                      ]
@@ -1582,16 +1640,6 @@ printListResult raw lr = do
 
   forM_ padded $ \row -> putStrLn $ intercalate " " row
  where
-  printTag Recommended        = color' Green "recommended"
-  printTag Latest             = color' Yellow "latest"
-  printTag Prerelease         = color' Red "prerelease"
-  printTag (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
-  printTag (UnknownTag t    ) = t
-  printTag Old                = ""
-
-  color' = case raw of
-    True  -> flip const
-    False -> color
 
   padTo str' x =
     let lstr = strWidth str'
@@ -1694,27 +1742,27 @@ checkForUpdates :: ( MonadReader AppState m
                 -> PlatformRequest
                 -> m ()
 checkForUpdates dls pfreq = do
-  forM_ (getLatest dls GHCup) $ \l -> do
+  forM_ (getLatest dls GHCup) $ \(l, _) -> do
     (Right ghc_ver) <- pure $ version $ prettyPVP ghcUpVer
     when (l > ghc_ver)
       $ $(logWarn)
           [i|New GHCup version available: #{prettyVer l}. To upgrade, run 'ghcup upgrade'|]
 
-  forM_ (getLatest dls GHC) $ \l -> do
+  forM_ (getLatest dls GHC) $ \(l, _) -> do
     mghc_ver <- latestInstalled GHC
     forM mghc_ver $ \ghc_ver ->
       when (l > ghc_ver)
         $ $(logWarn)
             [i|New GHC version available: #{prettyVer l}. To upgrade, run 'ghcup install ghc #{prettyVer l}'|]
 
-  forM_ (getLatest dls Cabal) $ \l -> do
+  forM_ (getLatest dls Cabal) $ \(l, _) -> do
     mcabal_ver <- latestInstalled Cabal
     forM mcabal_ver $ \cabal_ver ->
       when (l > cabal_ver)
         $ $(logWarn)
             [i|New Cabal version available: #{prettyVer l}. To upgrade, run 'ghcup install cabal #{prettyVer l}'|]
 
-  forM_ (getLatest dls HLS) $ \l -> do
+  forM_ (getLatest dls HLS) $ \(l, _) -> do
     mcabal_ver <- latestInstalled HLS
     forM mcabal_ver $ \cabal_ver ->
       when (l > cabal_ver)

bootstrap-haskell

@@ -1,5 +1,16 @@
 #!/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
 (
 
@@ -8,7 +19,7 @@
 export GHCUP_USE_XDG_DIRS
 
 if [ -n "${GHCUP_USE_XDG_DIRS}" ] ; then
-	GHCUP_DIR=${XDG_DATA_HOME:=$HOME/.local}/ghcup
+	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
@@ -23,8 +34,7 @@ die() {
     exit 2
 }
 
-edo()
+edo() {
-{
     "$@" || die "\"$*\" failed!"
 }
 
@@ -59,7 +69,7 @@ _done() {
 download_ghcup() {
 	_plat="$(uname -s)"
 	_arch=$(uname -m)
-	_ghver="0.1.11"
+	_ghver="0.1.12"
 	_base_url="https://downloads.haskell.org/~ghcup"
 
     case "${_plat}" in
@@ -114,6 +124,7 @@ download_ghcup() {
 
     edo chmod +x "${GHCUP_BIN}"/ghcup
 
+  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

cabal.ghc8103.project

@@ -0,0 +1,38 @@
+with-compiler: ghc-8.10.3
+
+packages: ./ghcup.cabal
+
+optional-packages: ./3rdparty/*/*.cabal
+
+source-repository-package
+    type: git
+    location: https://github.com/haskus/packages.git
+    tag: 80a1c5fc07f7226c424250ec17f674cd4d618f42
+    subdir: haskus-utils-types
+
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/hpath.git
+    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
+    subdir: hpath-io
+
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/hpath.git
+    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
+    subdir: hpath-directory
+
+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.ghc8103.project.freeze

@@ -0,0 +1,261 @@
+active-repositories: hackage.haskell.org:merge
+constraints: any.Cabal ==3.2.1.0,
+             any.HUnit ==1.6.2.0,
+             any.IfElse ==0.85,
+             any.QuickCheck ==2.14.2,
+             QuickCheck -old-random +templatehaskell,
+             any.StateVar ==1.2.1,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
+             any.aeson ==1.5.5.1,
+             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.2,
+             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
+             any.attoparsec ==0.13.2.4,
+             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.20,
+             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,
+             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.0,
+             any.deepseq ==1.4.4.0,
+             any.deferred-folds ==0.9.15,
+             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.2,
+             any.filepath ==1.4.2.1,
+             any.focus ==1.0.2,
+             any.foldl ==1.4.10,
+             any.free ==5.1.6,
+             any.fusion-plugin-types ==0.1.0,
+             any.generic-arbitrary ==0.1.0,
+             any.generics-sop ==0.5.1.0,
+             any.ghc-boot-th ==8.10.3,
+             any.ghc-prim ==0.6.1,
+             ghcup -internal-downloader -tar -tui,
+             any.happy ==1.20.0,
+             any.hashable ==1.3.0.0,
+             hashable -examples +integer-gmp +sse2 -sse41,
+             any.haskell-src-exts ==1.23.1,
+             any.haskell-src-meta ==0.8.5,
+             any.haskus-utils-data ==1.3,
+             any.haskus-utils-types ==1.5,
+             any.haskus-utils-variant ==3.0,
+             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.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.11.2,
+             any.microlens-mtl ==0.2.0.1,
+             any.microlens-th ==0.4.3.9,
+             any.mmorph ==1.1.4,
+             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.3,
+             any.optics-core ==0.3.0.1,
+             any.optics-extra ==0.3,
+             any.optics-th ==0.3.0.2,
+             any.optics-vl ==0.2.1,
+             any.optparse-applicative ==0.16.1.0,
+             optparse-applicative +process,
+             any.os-release ==1.0.1,
+             os-release -devel,
+             any.parallel ==3.2.2.0,
+             any.parsec ==3.1.14.0,
+             any.parser-combinators ==1.2.1,
+             parser-combinators -dev,
+             any.pretty ==1.1.3.6,
+             any.pretty-terminal ==0.1.0.0,
+             any.primitive ==0.7.0.1,
+             any.primitive-extras ==0.8,
+             any.primitive-unlifted ==0.1.3.0,
+             any.process ==1.6.9.0,
+             any.profunctors ==5.6.1,
+             any.quickcheck-arbitrary-adt ==0.3.1.0,
+             any.quickcheck-io ==0.2.0,
+             any.random ==1.2.0,
+             any.recursion-schemes ==5.2.1,
+             recursion-schemes +template-haskell,
+             any.regex-base ==0.94.0.0,
+             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.2,
+             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.0.2,
+             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,
+             any.th-expand-syns ==0.4.6.0,
+             any.th-lift ==0.8.2,
+             any.th-lift-instances ==0.1.18,
+             any.th-orphans ==0.13.11,
+             any.th-reify-many ==0.1.9,
+             any.these ==1.1.1.1,
+             these +assoc,
+             any.time ==1.9.3,
+             any.time-compat ==1.9.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.3,
+             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.2,
+             any.vty ==5.32,
+             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-02-04T20:08:20Z

ghcup-0.0.2.yaml

@@ -1117,7 +1117,6 @@ ghcupDownloads:
             unknown_versioning: *ghc-8101-32-deb9
     8.10.2:
       viTags:
-      - Latest
       - base-4.14.1.0
       viChangeLog: https://downloads.haskell.org/~ghc/8.10.2/docs/html/users_guide/8.10.2-notes.html
       viSourceDL:
@@ -1193,6 +1192,79 @@ ghcupDownloads:
               dlUri: https://files.hasufell.de/ghc/ghc-8.10.2-i386-alpine-linux.tar.xz
               dlSubdir: ghc-8.10.2
               dlHash: 9ee1cf1e85e9536088b3c9e80e975074e525ea378cd4eb156071bbc4b7b38327
+    8.10.3:
+      viTags:
+      - Latest
+      - base-4.14.1.0
+      viChangeLog: https://downloads.haskell.org/~ghc/8.10.3/docs/html/users_guide/8.10.3-notes.html
+      viSourceDL:
+        dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-src.tar.xz
+        dlSubdir: ghc-8.10.3
+        dlHash: 9c573a4621a78723950617c223559bdc325ea6a3409264aedf68f05510b0880b
+      viArch:
+        A_64:
+          Linux_Debian:
+            '9': &ghc-8103-64-deb9
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: 95e4aadea30701fe5ab84d15f757926d843ded7115e11c4cd827809ca830718d
+            '10': &ghc-8103-64-deb10
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: c8f3d9f0e61a89eaba1d3ad8fb2eced1af0e81576811261b887993bee12538ac
+            unknown_versioning: *ghc-8103-64-deb9
+          Linux_Ubuntu:
+            unknown_versioning: &ghc-8103-64-fedora
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-fedora27-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: f8739b12008712d6b6a9ffc6c39f9d05af77ef3bcb932c9aff20fa0893c8c159
+            '16.04': *ghc-8103-64-deb9
+            '18.04': *ghc-8103-64-deb9
+          Linux_Mint:
+            unknown_versioning: *ghc-8103-64-deb10
+          Linux_Fedora:
+            '27': *ghc-8103-64-fedora
+            unknown_versioning: *ghc-8103-64-fedora
+          Linux_CentOS:
+            '7': &ghc-8103-64-centos
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-centos7-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: f562ca61979ff1d21e34e69e59028cb742a8eff8d84e46bbd3a750f2ac7d8ed1
+            unknown_versioning: *ghc-8103-64-centos
+          Linux_RedHat:
+            unknown_versioning: *ghc-8103-64-centos
+          Linux_Alpine:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-alpine3.10-linux-integer-simple.tar.xz
+              dlSubdir: ghc-8.10.3-x86_64-unknown-linux
+              dlHash: 8506c478ebbfb5441c3c36c07c36fc8532cacb2b3e13c6733bd44cb17b3ce96c
+          Linux_AmazonLinux:
+            unknown_versioning: *ghc-8103-64-centos
+          Linux_UnknownLinux:
+            unknown_versioning: *ghc-8103-64-fedora
+          Darwin:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-apple-darwin.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: 2635f35d76e44e69afdfd37cae89d211975cc20f71f784363b72003e59f22015
+          FreeBSD:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-portbld-freebsd.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: 749007e995104db05cf6e3ad5bc36238cab8afac8055145661e5730e8f8af040
+        A_32:
+          Linux_Debian:
+            '9': &ghc-8103-32-deb9
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-i386-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: f0addd2a16b705f58ff9e8702c3ddf3e2d6bd0d3555707b5b5095e51bafee7b1
+            unknown_versioning: *ghc-8103-32-deb9
+          Linux_Ubuntu:
+            unknown_versioning: *ghc-8103-32-deb9
+          Linux_Mint:
+            unknown_versioning: *ghc-8103-32-deb9
+          Linux_UnknownLinux:
+            unknown_versioning: *ghc-8103-32-deb9
   Cabal:
     2.4.1.0:
       viTags: []

ghcup-0.0.3.yaml

@@ -95,7 +95,6 @@ ghcupDownloads:
     7.10.3:
       viTags:
       - base-4.8.2.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/7.10.3/docs/html/users_guide/release-7-10-1.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/7.10.3/ghc-7.10.3-src.tar.xz
@@ -158,7 +157,6 @@ ghcupDownloads:
     8.0.2:
       viTags:
       - base-4.9.1.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.0.2/docs/html/users_guide/8.0.1-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.0.2/ghc-8.0.2-src.tar.xz
@@ -216,7 +214,6 @@ ghcupDownloads:
     8.2.2:
       viTags:
       - base-4.10.1.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.2.2/docs/html/users_guide/8.2.2-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.2.2/ghc-8.2.2-src.tar.xz
@@ -283,7 +280,6 @@ ghcupDownloads:
     8.4.1:
       viTags:
       - base-4.11.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.4.1/docs/html/users_guide/8.4.1-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.4.1/ghc-8.4.1-src.tar.xz
@@ -332,7 +328,6 @@ ghcupDownloads:
     8.4.2:
       viTags:
       - base-4.11.1.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.4.2/docs/html/users_guide/8.4.2-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.4.2/ghc-8.4.2-src.tar.xz
@@ -387,7 +382,6 @@ ghcupDownloads:
     8.4.3:
       viTags:
       - base-4.11.1.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.4.3/docs/html/users_guide/8.4.3-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.4.3/ghc-8.4.3-src.tar.xz
@@ -510,7 +504,6 @@ ghcupDownloads:
     8.6.1:
       viTags:
       - base-4.12.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.6.1/docs/html/users_guide/8.6.1-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.6.1/ghc-8.6.1-src.tar.xz
@@ -565,7 +558,6 @@ ghcupDownloads:
     8.6.2:
       viTags:
       - base-4.12.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.6.2/docs/html/users_guide/8.6.2-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.6.2/ghc-8.6.2-src.tar.xz
@@ -611,7 +603,6 @@ ghcupDownloads:
     8.6.3:
       viTags:
       - base-4.12.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.6.3/docs/html/users_guide/8.6.3-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.6.3/ghc-8.6.3-src.tar.xz
@@ -675,7 +666,6 @@ ghcupDownloads:
     8.6.4:
       viTags:
       - base-4.12.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.6.4/docs/html/users_guide/8.6.4-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.6.4/ghc-8.6.4-src.tar.xz
@@ -798,7 +788,6 @@ ghcupDownloads:
     8.8.1:
       viTags:
       - base-4.13.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.8.1/docs/html/users_guide/8.8.1-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.8.1/ghc-8.8.1-src.tar.xz
@@ -857,7 +846,6 @@ ghcupDownloads:
     8.8.2:
       viTags:
       - base-4.13.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.8.2/docs/html/users_guide/8.8.2-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.8.2/ghc-8.8.2-src.tar.xz
@@ -916,7 +904,6 @@ ghcupDownloads:
     8.8.3:
       viTags:
       - base-4.13.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.8.3/docs/html/users_guide/8.8.3-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.8.3/ghc-8.8.3-src.tar.xz
@@ -1054,7 +1041,6 @@ ghcupDownloads:
     8.10.1:
       viTags:
       - base-4.14.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.10.1/docs/html/users_guide/8.10.1-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.10.1/ghc-8.10.1-src.tar.xz
@@ -1131,7 +1117,6 @@ ghcupDownloads:
             unknown_versioning: *ghc-8101-32-deb9
     8.10.2:
       viTags:
-      - Latest
       - base-4.14.1.0
       viChangeLog: https://downloads.haskell.org/~ghc/8.10.2/docs/html/users_guide/8.10.2-notes.html
       viSourceDL:
@@ -1207,82 +1192,149 @@ ghcupDownloads:
               dlUri: https://files.hasufell.de/ghc/ghc-8.10.2-i386-alpine-linux.tar.xz
               dlSubdir: ghc-8.10.2
               dlHash: 9ee1cf1e85e9536088b3c9e80e975074e525ea378cd4eb156071bbc4b7b38327
-    9.0.0.20200925:
+    8.10.3:
+      viTags:
+      - Latest
+      - base-4.14.1.0
+      viChangeLog: https://downloads.haskell.org/~ghc/8.10.3/docs/html/users_guide/8.10.3-notes.html
+      viSourceDL:
+        dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-src.tar.xz
+        dlSubdir: ghc-8.10.3
+        dlHash: 9c573a4621a78723950617c223559bdc325ea6a3409264aedf68f05510b0880b
+      viArch:
+        A_64:
+          Linux_Debian:
+            '9': &ghc-8103-64-deb9
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: 95e4aadea30701fe5ab84d15f757926d843ded7115e11c4cd827809ca830718d
+            '10': &ghc-8103-64-deb10
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: c8f3d9f0e61a89eaba1d3ad8fb2eced1af0e81576811261b887993bee12538ac
+            unknown_versioning: *ghc-8103-64-deb9
+          Linux_Ubuntu:
+            unknown_versioning: &ghc-8103-64-fedora
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-fedora27-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: f8739b12008712d6b6a9ffc6c39f9d05af77ef3bcb932c9aff20fa0893c8c159
+            '16.04': *ghc-8103-64-deb9
+            '18.04': *ghc-8103-64-deb9
+          Linux_Mint:
+            unknown_versioning: *ghc-8103-64-deb10
+          Linux_Fedora:
+            '27': *ghc-8103-64-fedora
+            unknown_versioning: *ghc-8103-64-fedora
+          Linux_CentOS:
+            '7': &ghc-8103-64-centos
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-centos7-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: f562ca61979ff1d21e34e69e59028cb742a8eff8d84e46bbd3a750f2ac7d8ed1
+            unknown_versioning: *ghc-8103-64-centos
+          Linux_RedHat:
+            unknown_versioning: *ghc-8103-64-centos
+          Linux_Alpine:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-alpine3.10-linux-integer-simple.tar.xz
+              dlSubdir: ghc-8.10.3-x86_64-unknown-linux
+              dlHash: 8506c478ebbfb5441c3c36c07c36fc8532cacb2b3e13c6733bd44cb17b3ce96c
+          Linux_AmazonLinux:
+            unknown_versioning: *ghc-8103-64-centos
+          Linux_UnknownLinux:
+            unknown_versioning: *ghc-8103-64-fedora
+          Darwin:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-apple-darwin.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: 2635f35d76e44e69afdfd37cae89d211975cc20f71f784363b72003e59f22015
+          FreeBSD:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-portbld-freebsd.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: 749007e995104db05cf6e3ad5bc36238cab8afac8055145661e5730e8f8af040
+        A_32:
+          Linux_Debian:
+            '9': &ghc-8103-32-deb9
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-i386-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: f0addd2a16b705f58ff9e8702c3ddf3e2d6bd0d3555707b5b5095e51bafee7b1
+            unknown_versioning: *ghc-8103-32-deb9
+          Linux_Ubuntu:
+            unknown_versioning: *ghc-8103-32-deb9
+          Linux_Mint:
+            unknown_versioning: *ghc-8103-32-deb9
+          Linux_UnknownLinux:
+            unknown_versioning: *ghc-8103-32-deb9
+    9.0.0.20201227:
       viTags:
       - Prerelease
       - base-4.15.0.0
       viSourceDL:
-        dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-src.tar.xz
+        dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-src.tar.xz
-        dlSubdir: ghc-9.0.0.20200925
+        dlSubdir: ghc-9.0.0.20201227
-        dlHash: 142189a3a741af1deb40020c031f05aebfc2b6fd077ffd0c230cf405587cdbb0
+        dlHash: de49a6d4c67bb8ef676c7e76ca48b3f174bb774a197794cf1518a7f7dd11e2cd
       viArch:
         A_64:
           Linux_Debian:
-            '9': &ghc-901a1-64-deb9
+            '9': &ghc-901r1-64-deb9
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-deb9-linux.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-x86_64-deb9-linux.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
+              dlSubdir: ghc-9.0.0.20201227
-              dlHash: d44ab6f933292066d3f4bafc7e1a4209f8044069f9360bd60a97d2de05a73db2
+              dlHash: 53f1d9b1cd7cbac4f4e683b5bcf2d08dd45852bd55218c7c5e965b5a78704f15
-            '10': &ghc-901a1-64-deb10
+            '10': &ghc-901r1-64-deb10
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-deb10-linux-dwarf.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-x86_64-deb10-linux-dwarf.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
+              dlSubdir: ghc-9.0.0.20201227
-              dlHash: 958f98a97d244899d986168c89e4babe2b85ceaa4b0cf1c4631ea1dfa82ad75e
+              dlHash: 646f3b91a4ea58be46545b493e08197a4345a71f74ec018be2b8fde496ffe1e4
-            unknown_versioning: *ghc-901a1-64-deb9
+            unknown_versioning: *ghc-901r1-64-deb9
           Linux_Ubuntu:
-            unknown_versioning: &ghc-901a1-64-fedora
+            unknown_versioning: &ghc-901r1-64-fedora
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-fedora27-linux.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-x86_64-fedora27-linux.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
+              dlSubdir: ghc-9.0.0.20201227
-              dlHash: 2711afabbaab7abd1b8fdf846802ce6ca8e531641d64bbf75780d4de64180dca
+              dlHash: a6483262e5c999701b948107f5b9e77d705333f4b61b37b1c27b4abd28dd186c
-            '16.04': *ghc-901a1-64-deb9
+            '16.04': *ghc-901r1-64-deb9
-            '18.04': *ghc-901a1-64-deb9
+            '18.04': *ghc-901r1-64-deb9
           Linux_Mint:
-            unknown_versioning: *ghc-901a1-64-deb10
+            unknown_versioning: *ghc-901r1-64-deb10
           Linux_Fedora:
-            '27': *ghc-901a1-64-fedora
+            '27': *ghc-901r1-64-fedora
-            unknown_versioning: *ghc-901a1-64-fedora
+            unknown_versioning: *ghc-901r1-64-fedora
           Linux_CentOS:
-            '7': &ghc-901a1-64-centos
+            '7': &ghc-901r1-64-centos
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-centos7-linux.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-x86_64-centos7-linux.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
+              dlSubdir: ghc-9.0.0.20201227
-              dlHash: 5f6cd94e0d3917fa5c87031706e665f5d9b997f5c991c9c4c4e2900c39dc98ac
+              dlHash: 563370553544c825b0f43427065af789c56ee7ec9cccd497b9dc28c13fc537c5
-            unknown_versioning: *ghc-901a1-64-centos
+            unknown_versioning: *ghc-901r1-64-centos
           Linux_RedHat:
-            unknown_versioning: *ghc-901a1-64-centos
+            unknown_versioning: *ghc-901r1-64-centos
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-alpine3.10-linux-integer-simple.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-x86_64-alpine3.10-linux-integer-simple.tar.xz
-              dlSubdir: ghc-9.0.0.20200925-x86_64-unknown-linux
+              dlSubdir: ghc-9.0.0.20201227-x86_64-unknown-linux
-              dlHash: 05c0176e39cc89a95047060a589df0686ea1eb99b3de7f2cfadbe5e68bf93f68
+              dlHash: 21d1ffce74032a8f2e808c9160624a41d9d7a129e4e376845d7dd422b290fba2
           Linux_AmazonLinux:
-            unknown_versioning: *ghc-901a1-64-centos
+            unknown_versioning: *ghc-901r1-64-centos
           Linux_UnknownLinux:
-            unknown_versioning: *ghc-901a1-64-fedora
+            unknown_versioning: *ghc-901r1-64-fedora
           Darwin:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-apple-darwin.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-x86_64-apple-darwin.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
+              dlSubdir: ghc-9.0.0.20201227
-              dlHash: fb85a78f2bdad53c591261e21c80f3f50fa2b68bbb22632d9be6960af7b27813
+              dlHash: e6e5bf34c002d52d7108b9d4c8621ae3d21059509f8868bb81b0ba4fda6320da
-          FreeBSD:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-unknown-freebsd.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
-              dlHash: 1e094cbbf9636b1f231bc99e44197fe7a05f570cf46f079bba1a0ca796c3c30c
         A_32:
           Linux_Debian:
-            '9': &ghc-901a1-32-deb9
+            '9': &ghc-901r1-32-deb9
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-i386-deb9-linux.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-i386-deb9-linux.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
+              dlSubdir: ghc-9.0.0.20201227
-              dlHash: a533641720c33f953ca5d100bc7da219d4cf52eae081c94c97b9ac4cbd9c1d06
+              dlHash: 1e3348e2288c60b763dc4e74e4a69b17ae261edb383a7a5220a879c35d530cda
-            unknown_versioning: *ghc-901a1-32-deb9
+            unknown_versioning: *ghc-901r1-32-deb9
           Linux_Ubuntu:
-            unknown_versioning: *ghc-901a1-32-deb9
+            unknown_versioning: *ghc-901r1-32-deb9
           Linux_Mint:
-            unknown_versioning: *ghc-901a1-32-deb9
+            unknown_versioning: *ghc-901r1-32-deb9
           Linux_UnknownLinux:
-            unknown_versioning: *ghc-901a1-32-deb9
+            unknown_versioning: *ghc-901r1-32-deb9
   Cabal:
     2.4.1.0:
-      viTags:
+      viTags: []
-        - old
       viChangeLog: https://downloads.haskell.org/~cabal/cabal-install-2.4.1.0/changelog
       viArch:
         A_64:
@@ -1313,8 +1365,7 @@ ghcupDownloads:
               dlSubdir:
               dlHash: b2da736cc27609442b10f77fc1a687aba603a7a33045b722dbf1a0066fade198
     3.0.0.0:
-      viTags:
+      viTags: []
-        - old
       viChangeLog: https://downloads.haskell.org/~cabal/cabal-install-3.0.0.0/changelog
       viArch:
         A_64:
@@ -1400,7 +1451,7 @@ ghcupDownloads:
               dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
               dlHash: 9705e16d03497b46be4ad477e6c64d10890af853eafa8a9adf6dba89aa9e05f7
   GHCup:
-    0.1.11:
+    0.1.12:
       viTags:
       - Recommended
       - Latest
@@ -1410,40 +1461,40 @@ ghcupDownloads:
         A_64:
           Linux_UnknownLinux:
             unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-linux-ghcup-0.1.11
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-linux-ghcup-0.1.12
-              dlHash: 99d97c9a1dce76892001e5cffd50cc23bf804f2282998c546d1b965aa2179699
+              dlHash: 83088569ddf2d35df494f440dedd9c8eb2a53276d665f7de731f6554986c2ddb
           Darwin:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-apple-darwin-ghcup-0.1.11
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-apple-darwin-ghcup-0.1.12
-              dlHash: 4b91dcd9bfdc40534156b8fadea3f317b3c44af1255169895f4911a221f819c6
+              dlHash: 1336efb0851e1ed267838f97f6c36cbceb5363ad0ae359f04f1bc43d0c5f2cef
           FreeBSD:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-portbld-freebsd-ghcup-0.1.11
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-portbld-freebsd-ghcup-0.1.12
-              dlHash: 6f04ce98d3f3eb9299ce74f8264aa956f0dc38a64a3bd12ee048b7f146e9e1b4
+              dlHash: a72123e972a53d667574c7d276a81842701a07fce2b434e4d856e561c34772fe
           Linux_Alpine:
             unknown_versioning: *ghcup-64
         A_32:
           Linux_UnknownLinux:
             unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/i386-linux-ghcup-0.1.11
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/i386-linux-ghcup-0.1.12
-              dlHash: ec339e4c2b8b4d502f66a03c0d3f112cb68cd922dd3c4a6f66323628cf6a76c2
+              dlHash: 4bc79a272dfcd16143f08d9f8e33f2fef66dc53f3a0659bdab56ac3cbecf9e84
           Linux_Alpine:
             unknown_versioning: *ghcup-32
   HLS:
-    0.5.1:
+    0.8.0:
       viTags:
         - Recommended
         - Latest
-      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#051
+      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#080
       viArch:
         A_64:
           Linux_UnknownLinux:
             unknown_versioning: &hls-64
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.5.1/haskell-language-server-Linux-0.5.1.tar.gz
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.8.0/haskell-language-server-Linux-0.8.0.tar.gz
-              dlHash: 8f80a663823033b1d9322de6f86b329e6f7b3f93ba2faea4677989767cb844eb
+              dlHash: ba1306ab1af7a5fa1174b19bc3aa8904f5b238d9d6eac04d07fd692db9af4534
           Darwin:
             unknown_versioning:
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.5.1/haskell-language-server-macOS-0.5.1.tar.gz
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.8.0/haskell-language-server-macOS-0.8.0.tar.gz
-              dlHash: a4e557a754df6d2e668714909554a15fea9803f3ff5883268bcf92bf009b45b2
+              dlHash: 1c1668bb455a5164df62774e6fb8f8f91a831ce527d9e5f89f453fb28ef54622
           Linux_Alpine:
             unknown_versioning: *hls-64

ghcup.cabal

@@ -15,7 +15,7 @@ maintainer:         hasufell@posteo.de
 copyright:          Julian Ospald 2020
 category:           System
 build-type:         Simple
-extra-source-files: CHANGELOG.md
+extra-doc-files:    CHANGELOG.md
 
 source-repository head
   type:     git
@@ -431,6 +431,7 @@ executable ghcup-gen
     , optics
     , optparse-applicative
     , pretty-terminal
+    , regex-posix
     , resourcet
     , safe-exceptions
     , string-interpolate

lib/GHCup.hs

@@ -74,7 +74,7 @@ import           Prelude                 hiding ( abs
                                                 )
 import           Safe                    hiding ( at )
 import           System.IO.Error
-import           System.Posix.Env.ByteString    ( getEnvironment )
+import           System.Posix.Env.ByteString    ( getEnvironment, getEnv )
 import           System.Posix.FilePath          ( getSearchPath, takeExtension )
 import           System.Posix.Files.ByteString
 import           Text.Regex.Posix
@@ -134,10 +134,23 @@ installGHCBindist dlinfo ver pfreq = do
   -- prepare paths
   ghcdir <- lift $ ghcupGHCDir tver
 
+  toolchainSanityChecks
+  
   liftE $ installPackedGHC dl (view dlSubdir dlinfo) ghcdir ver pfreq
 
   liftE $ postGHCInstall tver
 
+ where
+  toolchainSanityChecks = do
+    r <- forM ["CC", "LD"] (liftIO . getEnv)
+    case catMaybes r of
+      [] -> pure ()
+      _ -> do
+        lift $ $(logWarn) "CC/LD environment variable is set. This will change the compiler/linker"
+        lift $ $(logWarn) "GHC uses internally and can cause defunct GHC in some cases (e.g. in Anaconda"
+        lift $ $(logWarn) "environments). If you encounter problems, unset CC and LD and reinstall."
+
+
 -- | Install a packed GHC distribution. This only deals with unpacking and the GHC
 -- build system and nothing else.
 installPackedGHC :: ( MonadMask m
@@ -320,7 +333,7 @@ installCabalBindist dlinfo ver (PlatformRequest {..}) = do
       (path </> cabalFile)
       (destPath)
       Overwrite
-    lift $ chmod_777 destPath
+    lift $ chmod_755 destPath
 
 
 -- | Installs cabal into @~\/.ghcup\/bin/cabal-\<ver\>@ and
@@ -436,7 +449,7 @@ installHLSBindist dlinfo ver (PlatformRequest {..}) = do
         (path </> f)
         (inst </> toF)
         Overwrite
-      lift $ chmod_777 (inst </> toF)
+      lift $ chmod_755 (inst </> toF)
 
     -- install haskell-language-server-wrapper
     let wrapper = [rel|haskell-language-server-wrapper|]
@@ -445,7 +458,7 @@ installHLSBindist dlinfo ver (PlatformRequest {..}) = do
       (path </> wrapper)
       (inst </> toF)
       Overwrite
-    lift $ chmod_777 (inst </> toF)
+    lift $ chmod_755 (inst </> toF)
 
 
 -- | Installs hls binaries @haskell-language-server-\<ghcver\>@
@@ -522,8 +535,8 @@ setGHC ver sghc = do
   -- with old ghcup)
   case sghc of
     SetGHCOnly -> liftE $ rmPlain (_tvTarget ver)
-    SetGHC_XY  -> lift $ rmMajorSymlinks ver
+    SetGHC_XY  -> liftE $ rmMajorSymlinks ver
-    SetGHC_XYZ -> lift $ rmMinorSymlinks ver
+    SetGHC_XYZ -> liftE $ rmMinorSymlinks ver
 
   -- for ghc tools (ghc, ghci, haddock, ...)
   verfiles <- ghcToolFiles ver
@@ -924,16 +937,17 @@ rmGHCVer ver = do
     lift $ $(logInfo) [i|Removing ghc symlinks|]
     liftE $ rmPlain (_tvTarget ver)
 
-  lift $ $(logInfo) [i|Removing directory recursively: #{toFilePath dir}|]
-  liftIO $ deleteDirRecursive dir
-
   lift $ $(logInfo) [i|Removing ghc-x.y.z symlinks|]
-  lift $ rmMinorSymlinks ver
+  liftE $ rmMinorSymlinks ver
 
   lift $ $(logInfo) [i|Removing/rewiring ghc-x.y symlinks|]
   -- first remove
-  handle (\(_ :: ParseError) -> pure ()) $ lift $ rmMajorSymlinks ver
+  handle (\(_ :: ParseError) -> pure ()) $ liftE $ rmMajorSymlinks ver
   -- then fix them (e.g. with an earlier version)
+
+  lift $ $(logInfo) [i|Removing directory recursively: #{toFilePath dir}|]
+  liftIO $ deleteDirRecursive dir
+
   v' <-
     handle
       (\(e :: ParseError) -> lift $ $(logWarn) [i|#{e}|] >> pure Nothing)
@@ -1294,18 +1308,30 @@ upgradeGHCup :: ( MonadMask m
 upgradeGHCup dls mtarget force pfreq = do
   AppState {dirs = Dirs {..}} <- lift ask
   lift $ $(logInfo) [i|Upgrading GHCup...|]
-  let latestVer = fromJust $ getLatest dls GHCup
+  let latestVer = fromJust $ fst <$> getLatest dls GHCup
   when (not force && (latestVer <= pvpToVersion ghcUpVer)) $ throwE NoUpdate
   dli   <- lE $ getDownloadInfo GHCup latestVer pfreq dls
   tmp   <- lift withGHCupTmpDir
   let fn = [rel|ghcup|]
   p <- liftE $ download dli tmp (Just fn)
-  let fullDest = fromMaybe (binDir </> fn) mtarget
+  let destDir = dirname destFile
-  liftIO $ hideError NoSuchThing $ deleteFile fullDest
+      destFile = fromMaybe (binDir </> fn) mtarget
+  lift $ $(logDebug) [i|mkdir -p #{toFilePath destDir}|]
+  liftIO $ createDirRecursive' destDir
+  lift $ $(logDebug) [i|rm -f #{toFilePath destFile}|]
+  liftIO $ hideError NoSuchThing $ deleteFile destFile
+  lift $ $(logDebug) [i|cp #{toFilePath p} #{toFilePath destFile}|]
   handleIO (throwE . CopyError . show) $ liftIO $ copyFile p
-                                                           fullDest
+                                                           destFile
                                                            Overwrite
-  lift $ chmod_777 fullDest
+  lift $ chmod_755 destFile
+
+  liftIO (isInPath destFile) >>= \b -> when (not b) $
+    lift $ $(logWarn) [i|"#{toFilePath (dirname destFile)}" is not in PATH! You have to add it in order to use ghcup.|]
+  liftIO (isShadowed destFile) >>= \case
+    Nothing -> pure ()
+    Just pa -> lift $ $(logWarn) [i|ghcup is shadowed by "#{toFilePath pa}". The upgrade will not be in effect, unless you remove "#{toFilePath pa}" or make sure "#{toFilePath destDir}" comes before "#{toFilePath (dirname pa)}" in PATH.|]
+
   pure latestVer
 
 

lib/GHCup/Download.hs

@@ -57,6 +57,7 @@ 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
@@ -292,7 +293,8 @@ getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
   (case p of
     -- non-musl won't work on alpine
     Linux Alpine -> with_distro <|> without_distro_ver
-    _ -> with_distro <|> without_distro_ver <|> without_distro)
+    _            -> with_distro <|> without_distro_ver <|> without_distro
+  )
 
  where
   with_distro        = distro_preview id id
@@ -300,7 +302,18 @@ getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
   without_distro     = distro_preview (set _Linux UnknownLinux) (const Nothing)
 
   distro_preview f g =
-    preview (ix t % ix v % viArch % ix a % ix (f p) % ix (g mv)) dls
+    let platformVersionSpec =
+          preview (ix t % ix v % viArch % ix a % ix (f p)) dls
+        mv' = g mv
+    in  fmap snd
+          .   find
+                (\(mverRange, _) -> maybe
+                  (mv' == Nothing)
+                  (\range -> maybe False (flip versionRange range) mv')
+                  mverRange
+                )
+          .   M.toList
+          =<< platformVersionSpec
 
 
 -- | Tries to download from the given http or https url

lib/GHCup/Errors.hs

@@ -67,6 +67,10 @@ data CopyError = CopyError String
 data TagNotFound = TagNotFound Tag Tool
   deriving Show
 
+-- | Unable to find a version of a tool.
+data VerNotFound = VerNotFound Version Tool
+  deriving Show
+
 -- | The tool (such as GHC) is already installed with that version.
 data AlreadyInstalled = AlreadyInstalled Tool Version
   deriving Show

lib/GHCup/Requirements.hs

@@ -14,8 +14,10 @@ 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
@@ -23,6 +25,7 @@ import           Prelude                 hiding ( abs
                                                 , writeFile
                                                 )
 
+import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 
 
@@ -33,15 +36,25 @@ getCommonRequirements :: PlatformResult
                       -> ToolRequirements
                       -> Maybe Requirements
 getCommonRequirements pr tr =
-  preview (ix GHC % ix Nothing % ix (_platform pr) % ix (_distroVersion pr)) tr
+  with_distro <|> without_distro_ver <|> without_distro
-    <|> preview (ix GHC % ix Nothing % ix (_platform pr) % ix Nothing) tr
+ where
-    <|> preview
+  with_distro        = distro_preview _platform _distroVersion
-          ( ix GHC
+  without_distro_ver = distro_preview _platform (const Nothing)
-          % ix Nothing
+  without_distro     = distro_preview (set _Linux UnknownLinux . _platform) (const Nothing)
-          % ix (set _Linux UnknownLinux $ _platform pr)
+
-          % ix Nothing
+  distro_preview f g =
-          )
+    let platformVersionSpec =
-          tr
+          preview (ix GHC % ix Nothing % ix (f pr)) tr
+        mv' = g pr
+    in  fmap snd
+          .   find
+                (\(mverRange, _) -> maybe
+                  (mv' == Nothing)
+                  (\range -> maybe False (flip versionRange range) mv')
+                  mverRange
+                )
+          .   M.toList
+          =<< platformVersionSpec
 
 
 prettyRequirements :: Requirements -> T.Text

lib/GHCup/Types.hs

@@ -14,6 +14,7 @@ Portability : POSIX
 module GHCup.Types where
 
 import           Data.Map.Strict                ( Map )
+import           Data.List.NonEmpty             ( NonEmpty (..) )
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           HPath
@@ -46,7 +47,7 @@ data GHCupInfo = GHCupInfo
 type ToolRequirements = Map Tool ToolReqVersionSpec
 type ToolReqVersionSpec = Map (Maybe Version) PlatformReqSpec
 type PlatformReqSpec = Map Platform PlatformReqVersionSpec
-type PlatformReqVersionSpec = Map (Maybe Versioning) Requirements
+type PlatformReqVersionSpec = Map (Maybe VersionRange) Requirements
 
 
 data Requirements = Requirements
@@ -70,7 +71,7 @@ type GHCupDownloads = Map Tool ToolVersionSpec
 type ToolVersionSpec = Map Version VersionInfo
 type ArchitectureSpec = Map Architecture PlatformSpec
 type PlatformSpec = Map Platform PlatformVersionSpec
-type PlatformVersionSpec = Map (Maybe Versioning) DownloadInfo
+type PlatformVersionSpec = Map (Maybe VersionRange) DownloadInfo
 
 
 -- | An installable tool.
@@ -78,16 +79,20 @@ 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)
 
@@ -171,7 +176,7 @@ data DownloadInfo = DownloadInfo
   , _dlSubdir :: Maybe TarDir
   , _dlHash   :: Text
   }
-  deriving (Eq, GHC.Generic, Show)
+  deriving (Eq, Ord, GHC.Generic, Show)
 
 
 
@@ -184,7 +189,7 @@ 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, GHC.Generic, Show)
+            deriving (Eq, Ord, GHC.Generic, Show)
 
 
 -- | Where to fetch GHCupDownloads from.
@@ -307,7 +312,7 @@ data PlatformResult = PlatformResult
 
 prettyPlatform :: PlatformResult -> String
 prettyPlatform PlatformResult { _platform = plat, _distroVersion = Just v' }
-  = show plat <> ", " <> show v'
+  = show plat <> ", " <> T.unpack (prettyV v')
 prettyPlatform PlatformResult { _platform = plat, _distroVersion = Nothing }
   = show plat
 
@@ -344,3 +349,19 @@ prettyTVer :: GHCTargetVersion -> Text
 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)
+

lib/GHCup/Types/JSON.hs

@@ -22,22 +22,28 @@ 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
@@ -111,10 +117,10 @@ instance ToJSONKey (Maybe Versioning) where
 
 instance FromJSONKey (Maybe Versioning) where
   fromJSONKey = FromJSONKeyTextParser $ \t ->
-    if t == T.pack "unknown_versioning" then pure Nothing else pure $ just t
+    if t == T.pack "unknown_versioning" then pure Nothing else just t
    where
     just t = case versioning t of
-      Right x -> pure x
+      Right x -> pure $ Just x
       Left  e -> fail $ "Failure in (Maybe Versioning) (FromJSONKey)" <> show e
 
 instance ToJSONKey Platform where
@@ -157,10 +163,10 @@ instance ToJSONKey (Maybe Version) where
 
 instance FromJSONKey (Maybe Version) where
   fromJSONKey = FromJSONKeyTextParser $ \t ->
-    if t == T.pack "unknown_version" then pure Nothing else pure $ just t
+    if t == T.pack "unknown_version" then pure Nothing else just t
    where
     just t = case version t of
-      Right x -> pure x
+      Right x -> pure $ Just x
       Left  e -> fail $ "Failure in (Maybe Version) (FromJSONKey)" <> show e
 
 instance ToJSON Version where
@@ -220,3 +226,101 @@ instance FromJSON TarDir where
     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/Utils.hs

@@ -112,33 +112,40 @@ ghcLinkDestination tool ver = do
 
 
 -- | Removes the minor GHC symlinks, e.g. ghc-8.6.5.
-rmMinorSymlinks :: (MonadReader AppState m, MonadIO m, MonadLogger m) => GHCTargetVersion -> m ()
+rmMinorSymlinks :: ( MonadReader AppState m
-rmMinorSymlinks GHCTargetVersion {..} = do
+                   , MonadIO m
-  AppState { dirs = Dirs {..} } <- ask
+                   , MonadLogger m
-
+                   , MonadThrow m
-  files  <- liftIO $ findFiles'
+                   , MonadFail m
-    binDir
+                   , MonadReader AppState m
-    (  maybe mempty (\x -> MP.chunk (x <> "-")) _tvTarget
+                   )
-    *> parseUntil1 (MP.chunk $ prettyVer _tvVersion)
+                => GHCTargetVersion
-    *> (MP.chunk $ prettyVer _tvVersion)
+                -> Excepts '[NotInstalled] m ()
-    *> MP.eof
+rmMinorSymlinks tv@(GHCTargetVersion {..}) = do
-    )
+  AppState { dirs = Dirs {..} } <- lift ask
 
+  files                         <- liftE $ ghcToolFiles tv
   forM_ files $ \f -> do
-    let fullF = (binDir </> f)
+    f_xyz <- liftIO $ parseRel (toFilePath f <> B.singleton _hyphen <> verToBS _tvVersion)
-    $(logDebug) [i|rm -f #{toFilePath fullF}|]
+    let fullF = (binDir </> f_xyz)
+    lift $ $(logDebug) [i|rm -f #{toFilePath fullF}|]
     liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
 
 
 -- | Removes the set ghc version for the given target, if any.
-rmPlain :: (MonadReader AppState m, MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
+rmPlain :: ( MonadReader AppState m
-  => Maybe Text -- ^ target
+           , MonadLogger m
+           , MonadThrow m
+           , MonadFail m
+           , MonadIO m
+           )
+        => Maybe Text -- ^ target
         -> Excepts '[NotInstalled] m ()
 rmPlain target = do
   AppState { dirs = Dirs {..} } <- lift ask
-  mtv <- lift $ ghcSet target
+  mtv                           <- lift $ ghcSet target
   forM_ mtv $ \tv -> do
-    files  <- liftE $ ghcToolFiles tv
+    files <- liftE $ ghcToolFiles tv
     forM_ files $ \f -> do
       let fullF = (binDir </> f)
       lift $ $(logDebug) [i|rm -f #{toFilePath fullF}|]
@@ -150,25 +157,25 @@ rmPlain target = do
 
 
 -- | Remove the major GHC symlink, e.g. ghc-8.6.
-rmMajorSymlinks :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m)
+rmMajorSymlinks :: ( MonadReader AppState m
+                   , MonadIO m
+                   , MonadLogger m
+                   , MonadThrow m
+                   , MonadFail m
+                   , MonadReader AppState m
+                   )
                 => GHCTargetVersion
-                -> m ()
+                -> Excepts '[NotInstalled] m ()
-rmMajorSymlinks GHCTargetVersion {..} = do
+rmMajorSymlinks tv@(GHCTargetVersion {..}) = do
-  AppState { dirs = Dirs {..} } <- ask
+  AppState { dirs = Dirs {..} } <- lift ask
   (mj, mi) <- getMajorMinorV _tvVersion
   let v' = intToText mj <> "." <> intToText mi
 
-  files  <- liftIO $ findFiles'
+  files                         <- liftE $ ghcToolFiles tv
-    binDir
-    (  maybe mempty (\x -> MP.chunk (x <> "-")) _tvTarget
-    *> parseUntil1 (MP.chunk v')
-    *> MP.chunk v'
-    *> MP.eof
-    )
-
   forM_ files $ \f -> do
-    let fullF = (binDir </> f)
+    f_xyz <- liftIO $ parseRel (toFilePath f <> B.singleton _hyphen <> E.encodeUtf8 v')
-    $(logDebug) [i|rm -f #{toFilePath fullF}|]
+    let fullF = (binDir </> f_xyz)
+    lift $ $(logDebug) [i|rm -f #{toFilePath fullF}|]
     liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
 
 
@@ -490,11 +497,11 @@ getGHCForMajor major' minor' mt = do
 getLatestGHCFor :: Int -- ^ major version component
                 -> Int -- ^ minor version component
                 -> GHCupDownloads
-                -> Maybe Version
+                -> Maybe (Version, VersionInfo)
 getLatestGHCFor major' minor' dls = do
   join
-    . fmap (lastMay . filter (\v -> matchMajor v major' minor'))
+    . fmap (lastMay . filter (\(v, _) -> matchMajor v major' minor'))
-    . preview (ix GHC % to Map.keys)
+    . preview (ix GHC % to Map.toDescList)
     $ dls
 
 
@@ -589,17 +596,17 @@ getTagged tag =
   % _head
   )
 
-getLatest :: GHCupDownloads -> Tool -> Maybe Version
+getLatest :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
-getLatest av tool = headOf (ix tool % getTagged Latest % to fst) $ av
+getLatest av tool = headOf (ix tool % getTagged Latest) $ av
 
-getRecommended :: GHCupDownloads -> Tool -> Maybe Version
+getRecommended :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
-getRecommended av tool = headOf (ix tool % getTagged Recommended % to fst) $ av
+getRecommended av tool = headOf (ix tool % getTagged Recommended) $ av
 
 
 -- | Gets the latest GHC with a given base version.
-getLatestBaseVersion :: GHCupDownloads -> PVP -> Maybe Version
+getLatestBaseVersion :: GHCupDownloads -> PVP -> Maybe (Version, VersionInfo)
 getLatestBaseVersion av pvpVer =
-  headOf (ix GHC % getTagged (Base pvpVer) % to fst) av
+  headOf (ix GHC % getTagged (Base pvpVer)) av
 
 
 
@@ -788,3 +795,16 @@ createDirRecursive' p =
           _ -> throwIO e
       _ -> throwIO e
 
+
+getVersionInfo :: Version
+               -> Tool
+               -> GHCupDownloads
+               -> Maybe VersionInfo
+getVersionInfo v' tool dls =
+  headOf
+    ( ix tool
+    % to (Map.filterWithKey (\k _ -> k == v'))
+    % to Map.elems
+    % _head
+    )
+    dls

lib/GHCup/Utils/File.hs

@@ -407,6 +407,32 @@ 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)
@@ -440,13 +466,16 @@ isBrokenSymlink p =
         pure False
 
 
-chmod_777 :: (MonadLogger m, MonadIO m) => Path a -> m ()
+chmod_755 :: (MonadLogger m, MonadIO m) => Path a -> m ()
-chmod_777 (toFilePath -> fp) = do
+chmod_755 (toFilePath -> fp) = do
   let exe_mode =
-          newFilePerms
+          nullFileMode
             `unionFileModes` ownerExecuteMode
+            `unionFileModes` ownerReadMode
+            `unionFileModes` ownerWriteMode
             `unionFileModes` groupExecuteMode
+            `unionFileModes` groupReadMode
             `unionFileModes` otherExecuteMode
-  $(logDebug) [i|chmod 777 #{fp}|]
+            `unionFileModes` otherReadMode
+  $(logDebug) [i|chmod 755 #{fp}|]
   liftIO $ setFileMode fp exe_mode
-

lib/GHCup/Utils/MegaParsec.hs

@@ -74,13 +74,13 @@ 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 "-")
         <|> (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
@@ -97,3 +97,16 @@ ghcTargetVerP =
     if startsWithDigists && not (isJust (_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/Version.hs

@@ -3,7 +3,7 @@
 
 {-|
 Module      : GHCup.Version
-Description : Static version information
+Description : Version information and version handling.
 Copyright   : (c) Julian Ospald, 2020
 License     : LGPL-3.0
 Maintainer  : hasufell@hasufell.de
@@ -13,6 +13,7 @@ Portability : POSIX
 module GHCup.Version where
 
 import           GHCup.Utils.Version.QQ
+import           GHCup.Types
 
 import           Data.Versions
 import           URI.ByteString
@@ -22,7 +23,7 @@ import qualified Data.Text                     as T
 
 -- | This reflects the API version of the YAML.
 ghcupURL :: URI
-ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.3.yaml|]
+ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.4.yaml|]
 
 -- | The current ghcup version.
 ghcUpVer :: PVP
@@ -31,3 +32,16 @@ ghcUpVer = [pver|0.1.12|]
 -- | 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
+

test/GHCup/ArbitraryTypes.hs

@@ -159,6 +159,18 @@ 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)