Fix chmod on executables, wrt #97

Since script is served separately from the main source code (can be opened over
https://get-ghcup.haskell.org) - mention the script license to the reciever.

.gitlab-ci.yml

@@ -60,7 +60,12 @@ variables:
   script:
     - ./.gitlab/script/ghcup_version.sh
   variables:
-    JSON_VERSION: "0.0.2"
+    JSON_VERSION: "0.0.4"
+  artifacts:
+    expire_in: 2 week
+    paths:
+      - golden
+    when: on_failure
 
 .test_ghcup_version:linux:
   extends:
@@ -102,6 +107,29 @@ variables:
   only:
     - tags
 
+######## stack test ########
+
+test:linux:stack:
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_minimal.sh
+  script:
+    - ./.gitlab/script/ghcup_stack.sh
+  extends:
+    - .debian
+
+######## bootstrap test ########
+
+test:linux:bootstrap_script:
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_minimal.sh
+  script:
+    - ./.gitlab/script/ghcup_bootstrap.sh
+  variables:
+    GHC_VERSION: "8.8.4"
+    CABAL_VERSION: "3.2.0.0"
+  extends:
+    - .debian
+
 ######## linux test ########
 
 test:linux:recommended:

.gitlab/before_script/linux/install_deps_minimal.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+sudo apt-get update -y
+sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev git wget

.gitlab/script/ghcup_bootstrap.sh

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

.gitlab/script/ghcup_stack.sh

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

CHANGELOG.md

@@ -1,6 +1,25 @@
 # Revision history for ghcup
 
-## 0.1.11 -- ????-??-??
+## WIP
+
+* Fix to `ghcup` directory creation and placement for the XDG install mode.
+
+## 0.1.12 -- 2020-11-21
+
+* Fix disappearing HLS symlinks wrt #91
+* improve TUI:
+  - separators between tools sections
+  - reverse list order so latest is on top
+  - expand the blues selected bar
+  - show new latest versions in bright white
+* allow configuration file and setting TUI hotkeys wrt #41
+  - see https://gitlab.haskell.org/haskell/ghcup-hs#configuration for a more in-depth explanation
+* add a `--set` switch to `ghcup install ghc` to automatically set as default after install
+* emit warnings when CC/LD is set wrt #82
+* add support for version ranges in distro specifiers wrt #84
+  - e.g. `"(>= 19 && <= 20) || ==0.2.2"` is a valid version key for distro
+
+## 0.1.11 -- 2020-09-23
 
 * Add support for installing haskell-language-server, wrt #65
 * When compiling GHC from source create a bindist first, store that bindist in `~/.ghcup/cache` and install it, wrt #51

README.md

@@ -13,6 +13,7 @@ Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [p
      * [Manual install](#manual-install)
      * [Vim integration](#vim-integration)
    * [Usage](#usage)
+     * [Configuration](#configuration)
      * [Manpages](#manpages)
      * [Shell-completion](#shell-completion)
      * [Cross support](#cross-support)
@@ -80,6 +81,13 @@ ghcup upgrade
 Generally this is meant to be used with [`cabal-install`](https://hackage.haskell.org/package/cabal-install), which
 handles your haskell packages and can demand that [a specific version](https://cabal.readthedocs.io/en/latest/nix-local-build.html#cfg-flag---with-compiler)  of `ghc` is available, which `ghcup` can do.
 
+### Configuration
+
+A configuration file can be put in `~/.ghcup/config.yaml`. The default config file
+explaining all possible configurations can be found in this repo: [config.yaml](./config.yaml).
+
+Partial configuration is fine. Command line options always overwrite the config file settings.
+
 ### Manpages
 
 For man pages to work you need [man-db](http://man-db.nongnu.org/) as your `man` provider, then issue `man ghc`. Manpages only work for the currently set ghc.
@@ -111,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
 
@@ -163,6 +172,17 @@ In addition this script can also install `cabal-install`.
 
 ## Known problems
 
+### Custom ghc version names
+
+When installing ghc bindists with custom version names as outlined in
+[installing custom bindists](#installing-custom-bindists), then cabal might
+be unable to find the correct `ghc-pkg` (also see [#73](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/73))
+if you use `cabal build --with-compiler=ghc-foo`. Instead, point it to the full path, such as:
+`cabal build --with-compiler=$HOME/.ghcup/ghc/<version-name>/bin/ghc` or set that GHC version
+as the current one via: `ghcup set ghc <version-name>`.
+
+This problem doesn't exist for regularly installed GHC versions.
+
 ### Limited distributions supported
 
 Currently only GNU/Linux distributions compatible with the [upstream GHC](https://www.haskell.org/ghc/download_ghc_8_6_1.html#binaries) binaries are supported.

app/ghcup-gen/Validate.hs

@@ -122,6 +122,7 @@ validate dls = do
    where
     isUniqueTag Latest         = True
     isUniqueTag Recommended    = True
+    isUniqueTag Old            = False
     isUniqueTag Prerelease     = False
     isUniqueTag (Base       _) = False
     isUniqueTag (UnknownTag _) = False
@@ -192,7 +193,7 @@ validateTarballs dls = do
  where
   downloadAll dli = do
     dirs <- liftIO getDirs
-    let settings = Settings True False Never Curl False dirs
+    let settings = AppState (Settings True False Never Curl False GHCupURL) dirs defaultKeyBindings
     let runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
                                            , colorOutter  = B.hPut stderr
                                            , rawOutter    = (\_ -> pure ())

app/ghcup/BrickMain.hs

@@ -1,9 +1,11 @@
 {-# LANGUAGE CPP               #-}
 {-# LANGUAGE DataKinds         #-}
-{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE FlexibleContexts  #-}
-{-# LANGUAGE TypeApplications  #-}
-{-# LANGUAGE TemplateHaskell   #-}
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE ViewPatterns      #-}
 
 module BrickMain where
 
@@ -19,7 +21,10 @@ import           Brick
 import           Brick.Widgets.Border
 import           Brick.Widgets.Border.Style
 import           Brick.Widgets.Center
-import           Brick.Widgets.List
+import           Brick.Widgets.List             ( listSelectedFocusedAttr
+                                                , listSelectedAttr
+                                                , listAttr
+                                                )
 #if !defined(TAR)
 import           Codec.Archive
 #endif
@@ -31,10 +36,11 @@ import           Data.Bool
 import           Data.Functor
 import           Data.List
 import           Data.Maybe
-import           Data.Char
 import           Data.IORef
 import           Data.String.Interpolate
-import           Data.Vector                    ( Vector )
+import           Data.Vector                    ( Vector
+                                                , (!?)
+                                                )
 import           Data.Versions           hiding ( str )
 import           Haskus.Utils.Variant.Excepts
 import           Prelude                 hiding ( appendFile )
@@ -42,36 +48,82 @@ 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
 
 
-data AppState = AppState {
+
-    lr :: LR
+data BrickData = BrickData
-  , dls :: GHCupDownloads
+  { lr    :: [ListResult]
+  , dls   :: GHCupDownloads
   , pfreq :: PlatformRequest
-}
+  }
+  deriving Show
 
-type LR = GenericList String Vector ListResult
+data BrickSettings = BrickSettings
+  { showAll :: Bool
+  }
+  deriving Show
+
+data BrickInternalState = BrickInternalState
+  { clr :: Vector ListResult
+  , ix  :: Int
+  }
+  deriving Show
+
+data BrickState = BrickState
+  { appData     :: BrickData
+  , appSettings :: BrickSettings
+  , appState    :: BrickInternalState
+  , appKeys     :: KeyBindings
+  }
+  deriving Show
 
 
-keyHandlers :: [(Char, String, AppState -> EventM n (Next AppState))]
+keyHandlers :: KeyBindings
-keyHandlers =
+            -> [ ( Vty.Key
-  [ ('q', "Quit"     , halt)
+                 , BrickSettings -> String
-  , ('i', "Install"  , withIOAction install')
+                 , BrickState -> EventM n (Next BrickState)
-  , ('u', "Uninstall", withIOAction del')
+                 )
-  , ('s', "Set"      , withIOAction set')
+               ]
-  , ('c', "ChangeLog", withIOAction changelog')
+keyHandlers KeyBindings {..} =
+  [ (bQuit, const "Quit"     , halt)
+  , (bInstall, const "Install"  , withIOAction install')
+  , (bUninstall, const "Uninstall", withIOAction del')
+  , (bSet, const "Set"      , withIOAction set')
+  , (bChangelog, const "ChangeLog", withIOAction changelog')
+  , ( bShowAll
+    , (\BrickSettings {..} ->
+        if showAll then "Hide old versions" else "Show all versions"
+      )
+    , hideShowHandler
+    )
+  , (bUp, const "Up", \BrickState {..} -> continue (BrickState { appState = (moveCursor 1 appState Up), .. }))
+  , (bDown, const "Down", \BrickState {..} -> continue (BrickState { appState = (moveCursor 1 appState Down), .. }))
   ]
+ where
+  hideShowHandler (BrickState {..}) =
+    let newAppSettings   = appSettings { showAll = not . showAll $ appSettings }
+        newInternalState = constructList appData newAppSettings (Just appState)
+    in  continue (BrickState appData newAppSettings newInternalState appKeys)
 
 
-ui :: AppState -> Widget String
+showKey :: Vty.Key -> String
-ui AppState {..} =
+showKey (Vty.KChar c) = [c]
-  ( padBottom Max
+showKey (Vty.KUp) = "↑"
+showKey (Vty.KDown) = "↓"
+showKey key = tail (show key)
+
+
+ui :: BrickState -> Widget String
+ui BrickState { appSettings = as@(BrickSettings {}), ..}
+  = ( padBottom Max
     $ ( withBorderStyle unicode
       $ borderWithLabel (str "GHCup")
-      $ (center $ (header <=> hBorder <=> renderList renderItem True lr))
+      $ (center $ (header <=> hBorder <=> renderList' appState))
       )
     )
     <=> footer
@@ -82,15 +134,15 @@ ui AppState {..} =
       . txtWrap
       . T.pack
       . foldr1 (\x y -> x <> "  " <> y)
-      . (++ ["↑↓:Navigation"])
+      $ (fmap (\(key, s, _) -> (showKey key <> ":" <> s as)) $ keyHandlers appKeys)
-      $ (fmap (\(c, s, _) -> (c : ':' : s)) keyHandlers)
   header =
     (minHSize 2 $ emptyWidget)
       <+> (padLeft (Pad 2) $ minHSize 6 $ str "Tool")
       <+> (minHSize 15 $ str "Version")
       <+> (padLeft (Pad 1) $ minHSize 25 $ str "Tags")
       <+> (padLeft (Pad 5) $ str "Notes")
-  renderItem b listResult@(ListResult {..}) =
+  renderList' = withDefAttr listAttr . drawListElements renderItem True
+  renderItem _ b listResult@(ListResult {..}) =
     let marks = if
           | lSet       -> (withAttr "set" $ str "✔✔")
           | lInstalled -> (withAttr "installed" $ str "✓ ")
@@ -101,21 +153,23 @@ ui AppState {..} =
         dim = if lNoBindist
           then updateAttrMap (const dimAttributes) . withAttr "no-bindist"
           else id
-        active = if b then withAttr "active" else id
+        hooray
-    in  dim
+          | elem Latest lTag && not lInstalled =
+              withAttr "hooray"
+          | otherwise = id
+        active = if b then forceAttr "active" else id
+    in  hooray $ active $ dim
           (   marks
           <+> (( padLeft (Pad 2)
-               $ active
                $ minHSize 6
-               $ (str (fmap toLower . show $ lTool))
+               $ (printTool lTool)
                )
               )
-          <+> (minHSize 15 $ active $ (str ver))
+          <+> (minHSize 15 $ (str ver))
-          <+> (padLeft (Pad 1) $ minHSize 25 $ if null lTag
+          <+> (let l = catMaybes . fmap printTag $ sort lTag
-                then emptyWidget
+               in  padLeft (Pad 1) $ minHSize 25 $ if null l
-                else
+                     then emptyWidget
-                  foldr1 (\x y -> x <+> str "," <+> y)
+                     else foldr1 (\x y -> x <+> str "," <+> y) l
-                    $ (fmap printTag $ sort lTag)
               )
           <+> ( padLeft (Pad 5)
               $ let notes = printNotes listResult
@@ -123,13 +177,20 @@ ui AppState {..} =
                       then emptyWidget
                       else foldr1 (\x y -> x <+> str "," <+> y) $ notes
               )
+          <+> (vLimit 1 $ fill ' ')
           )
 
-  printTag Recommended        = withAttr "recommended" $ str "recommended"
+  printTag Recommended    = Just $ withAttr "recommended" $ str "recommended"
-  printTag Latest             = withAttr "latest" $ str "latest"
+  printTag Latest         = Just $ withAttr "latest" $ str "latest"
-  printTag Prerelease         = withAttr "prerelease" $ str "prerelease"
+  printTag Prerelease     = Just $ withAttr "prerelease" $ str "prerelease"
-  printTag (Base       pvp'') = str ("base-" ++ T.unpack (prettyPVP pvp''))
+  printTag (Base pvp'')   = Just $ str ("base-" ++ T.unpack (prettyPVP pvp''))
-  printTag (UnknownTag t    ) = str t
+  printTag Old            = Nothing
+  printTag (UnknownTag t) = Just $ str t
+
+  printTool Cabal = str "cabal"
+  printTool GHC = str "GHC"
+  printTool GHCup = str "GHCup"
+  printTool HLS = str "HLS"
 
   printNotes ListResult {..} =
     (if hlsPowered then [withAttr "hls-powered" $ str "hls-powered"] else mempty
@@ -137,13 +198,48 @@ ui AppState {..} =
       ++ (if fromSrc then [withAttr "compiled" $ str "compiled"] else mempty)
       ++ (if lStray then [withAttr "stray" $ str "stray"] else mempty)
 
+  -- | Draws the list elements.
+  --
+  -- Evaluates the underlying container up to, and a bit beyond, the
+  -- selected element. The exact amount depends on available height
+  -- for drawing and 'listItemHeight'. At most, it will evaluate up to
+  -- element @(i + h + 1)@ where @i@ is the selected index and @h@ is the
+  -- available height.
+  drawListElements :: (Int -> Bool -> ListResult -> Widget String)
+                   -> Bool
+                   -> BrickInternalState
+                   -> Widget String
+  drawListElements drawElem foc is@(BrickInternalState clr _) =
+    Widget Greedy Greedy $
+      let
+        es = clr
+        listSelected        = fmap fst $ listSelectedElement' is
+
+        drawnElements = flip V.imap es $ \i' e ->
+          let addSeparator w = case es !? (i' - 1) of
+                Just e' | lTool e' /= lTool e ->
+                  hBorder <=> w
+                _                             -> w
+
+              isSelected  = Just i' == listSelected
+              elemWidget  = drawElem i' isSelected e
+              selItemAttr = if foc
+                then withDefAttr listSelectedFocusedAttr
+                else withDefAttr listSelectedAttr
+              makeVisible = if isSelected then visible . selItemAttr else id
+          in  addSeparator $ makeVisible elemWidget
+
+      in render
+        $ viewport "GHCup" Vertical
+        $ vBox
+        $ V.toList drawnElements
 
 
 minHSize :: Int -> Widget n -> Widget n
 minHSize s' = hLimit s' . vLimit 1 . (<+> fill ' ')
 
 
-app :: App AppState e String
+app :: App BrickState e String
 app = App { appDraw         = \st -> [ui st]
           , appHandleEvent  = eventHandler
           , appStartEvent   = return
@@ -165,6 +261,7 @@ defaultAttributes = attrMap
   , ("compiled"     , Vty.defAttr `Vty.withForeColor` Vty.blue)
   , ("stray"        , Vty.defAttr `Vty.withForeColor` Vty.blue)
   , ("help"         , Vty.defAttr `Vty.withStyle` Vty.italic)
+  , ("hooray"       , Vty.defAttr `Vty.withForeColor` Vty.brightWhite)
   ]
 
 
@@ -176,72 +273,137 @@ dimAttributes = attrMap
   ]
 
 
+eventHandler :: BrickState -> BrickEvent n e -> EventM n (Next BrickState)
+eventHandler st@(BrickState {..}) ev = do
+  AppState { keyBindings = kb } <- liftIO $ readIORef settings'
+  case ev of
+    (MouseDown _ Vty.BScrollUp _ _) ->
+      continue (BrickState { appState = moveCursor 1 appState Up, .. })
+    (MouseDown _ Vty.BScrollDown _ _) ->
+      continue (BrickState { appState = moveCursor 1 appState Down, .. })
+    (VtyEvent (Vty.EvResize _ _)) -> continue st
+    (VtyEvent (Vty.EvKey Vty.KUp _)) ->
+      continue (BrickState { appState = (moveCursor 1 appState Up), .. })
+    (VtyEvent (Vty.EvKey Vty.KDown _)) ->
+      continue (BrickState { appState = (moveCursor 1 appState Down), .. })
+    (VtyEvent (Vty.EvKey key _)) ->
+      case find (\(key', _, _) -> key' == key) (keyHandlers kb) of
+        Nothing -> continue st
+        Just (_, _, handler) -> handler st
+    _ -> continue st
 
-eventHandler :: AppState -> BrickEvent n e -> EventM n (Next AppState)
+
-eventHandler st (VtyEvent (Vty.EvResize _               _)) = continue st
+moveCursor :: Int -> BrickInternalState -> Direction -> BrickInternalState
-eventHandler st (VtyEvent (Vty.EvKey    (Vty.KChar 'q') _)) = halt st
+moveCursor steps ais@(BrickInternalState {..}) direction =
-eventHandler st (VtyEvent (Vty.EvKey    Vty.KEsc        _)) = halt st
+  let newIx = if direction == Down then ix + steps else ix - steps
-eventHandler AppState {..} (VtyEvent (Vty.EvKey (Vty.KUp) _)) =
+  in  case clr !? newIx of
-  continue (AppState (listMoveUp lr) dls pfreq)
+        Just _  -> BrickInternalState { ix = newIx, .. }
-eventHandler AppState {..} (VtyEvent (Vty.EvKey (Vty.KDown) _)) =
+        Nothing -> ais
-  continue (AppState (listMoveDown lr) dls pfreq)
-eventHandler as (VtyEvent (Vty.EvKey (Vty.KChar c) _)) =
-  case find (\(c', _, _) -> c' == c) keyHandlers of
-    Nothing              -> continue as
-    Just (_, _, handler) -> handler as
-eventHandler st _ = continue st
 
 
 -- | Suspend the current UI and run an IO action in terminal. If the
 -- IO action returns a Left value, then it's thrown as userError.
-withIOAction :: (AppState -> (Int, ListResult) -> IO (Either String a))
+withIOAction :: (BrickState -> (Int, ListResult) -> IO (Either String a))
-             -> AppState
+             -> BrickState
-             -> EventM n (Next AppState)
+             -> EventM n (Next BrickState)
-withIOAction action as = case listSelectedElement (lr as) of
+withIOAction action as = case listSelectedElement' (appState as) of
   Nothing      -> continue as
   Just (ix, e) -> suspendAndResume $ do
     action as (ix, e) >>= \case
       Left  err -> putStrLn $ ("Error: " <> err)
       Right _   -> putStrLn "Success"
-    apps <- (fmap . fmap)
+    getAppData Nothing (pfreq . appData $ as) >>= \case
-      (\AppState {..} -> AppState { lr = listMoveTo ix lr, .. })
+      Right data' -> do
-      $ getAppState Nothing (pfreq as)
-    case apps of
-      Right nas -> do
         putStrLn "Press enter to continue"
         _ <- getLine
-        pure nas
+        pure (updateList data' as)
       Left err -> throwIO $ userError err
 
 
-install' :: AppState -> (Int, ListResult) -> IO (Either String ())
+-- | Update app data and list internal state based on new evidence.
-install' AppState {..} (_, ListResult {..}) = do
+-- This synchronises @BrickInternalState@ with @BrickData@
+-- and @BrickSettings@.
+updateList :: BrickData -> BrickState -> BrickState
+updateList appD (BrickState {..}) =
+  let newInternalState = constructList appD appSettings (Just appState)
+  in  BrickState { appState    = newInternalState
+                 , appData     = appD
+                 , appSettings = appSettings
+                 , appKeys     = appKeys
+                 }
+
+
+constructList :: BrickData
+              -> BrickSettings
+              -> Maybe BrickInternalState
+              -> BrickInternalState
+constructList appD appSettings mapp =
+  replaceLR (filterVisible (showAll appSettings)) (lr appD) mapp
+
+listSelectedElement' :: BrickInternalState -> Maybe (Int, ListResult)
+listSelectedElement' (BrickInternalState {..}) = fmap (ix, ) $ clr !? ix
+
+
+selectLatest :: Vector ListResult -> Int
+selectLatest v =
+  case V.findIndex (\ListResult {..} -> lTool == GHC && Latest `elem` lTag) v of
+    Just ix -> ix
+    Nothing -> 0
+
+
+-- | Replace the @appState@ or construct it based on a filter function
+-- and a new @[ListResult]@ evidence.
+-- When passed an existing @appState@, tries to keep the selected element.
+replaceLR :: (ListResult -> Bool)
+          -> [ListResult]
+          -> Maybe BrickInternalState
+          -> BrickInternalState
+replaceLR filterF lr s =
+  let oldElem = s >>= listSelectedElement'
+      newVec  = V.fromList . filter filterF $ lr
+      newSelected =
+        case oldElem >>= \(_, oldE) -> V.findIndex (toolEqual oldE) newVec of
+          Just ix -> ix
+          Nothing -> selectLatest newVec
+  in  BrickInternalState newVec newSelected
+ where
+  toolEqual e1 e2 =
+    lTool e1 == lTool e2 && lVer e1 == lVer e2 && lCross e1 == lCross e2
+
+
+filterVisible :: Bool -> ListResult -> Bool
+filterVisible showAll e | lInstalled e = True
+                        | showAll      = True
+                        | otherwise    = not (elem Old (lTag e))
+
+
+install' :: BrickState -> (Int, ListResult) -> IO (Either String ())
+install' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
   settings <- readIORef settings'
   l        <- readIORef logger'
   let runLogger = myLoggerT l
 
-  let
+  let run =
-    run =
+        runLogger
-      runLogger
+          . flip runReaderT settings
-        . flip runReaderT settings
+          . runResourceT
-        . runResourceT
+          . runE
-        . runE
+            @'[ AlreadyInstalled
-          @'[AlreadyInstalled
-            , UnknownArchive
 #if !defined(TAR)
-            , ArchiveResult
+              , ArchiveResult
 #endif
-            , FileDoesNotExistError
+              , UnknownArchive
-            , CopyError
+              , FileDoesNotExistError
-            , NoDownload
+              , CopyError
-            , NotInstalled
+              , NoDownload
-            , BuildFailed
+              , NotInstalled
-            , TagNotFound
+              , BuildFailed
-            , DigestError
+              , TagNotFound
-            , DownloadFailed
+              , DigestError
-            , NoUpdate
+              , DownloadFailed
-            , TarDirDoesNotExist
+              , NoUpdate
-            ]
+              , TarDirDoesNotExist
+              ]
 
   (run $ do
       case lTool of
@@ -262,7 +424,7 @@ install' AppState {..} (_, ListResult {..}) = do
 Also check the logs in ~/.ghcup/logs|]
 
 
-set' :: AppState -> (Int, ListResult) -> IO (Either String ())
+set' :: BrickState -> (Int, ListResult) -> IO (Either String ())
 set' _ (_, ListResult {..}) = do
   settings <- readIORef settings'
   l        <- readIORef logger'
@@ -271,7 +433,7 @@ set' _ (_, ListResult {..}) = do
   let run =
         runLogger
           . flip runReaderT settings
-          . runE @'[FileDoesNotExistError, NotInstalled, TagNotFound]
+          . runE @'[FileDoesNotExistError , NotInstalled , TagNotFound]
 
   (run $ do
       case lTool of
@@ -285,7 +447,7 @@ set' _ (_, ListResult {..}) = do
           VLeft  e -> pure $ Left [i|#{e}|]
 
 
-del' :: AppState -> (Int, ListResult) -> IO (Either String ())
+del' :: BrickState -> (Int, ListResult) -> IO (Either String ())
 del' _ (_, ListResult {..}) = do
   settings <- readIORef settings'
   l        <- readIORef logger'
@@ -305,37 +467,36 @@ del' _ (_, ListResult {..}) = do
           VLeft  e -> pure $ Left [i|#{e}|]
 
 
-changelog' :: AppState -> (Int, ListResult) -> IO (Either String ())
+changelog' :: BrickState -> (Int, ListResult) -> IO (Either String ())
-changelog' AppState {..} (_, ListResult {..}) = do
+changelog' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
   case getChangeLog dls lTool (Left lVer) of
     Nothing -> pure $ Left
       [i|Could not find ChangeLog for #{lTool}, version #{prettyVer lVer}|]
     Just uri -> do
       let cmd = case _rPlatform pfreq of
-                  Darwin  -> "open"
+            Darwin  -> "open"
-                  Linux _ -> "xdg-open"
+            Linux _ -> "xdg-open"
-                  FreeBSD -> "xdg-open"
+            FreeBSD -> "xdg-open"
       exec cmd True [serializeURIRef' uri] Nothing Nothing >>= \case
         Right _ -> pure $ Right ()
         Left  e -> pure $ Left [i|#{e}|]
 
 
-uri' :: IORef (Maybe URI)
+settings' :: IORef AppState
-{-# NOINLINE uri' #-}
-uri' = unsafePerformIO (newIORef Nothing)
-
-
-settings' :: IORef Settings
 {-# NOINLINE settings' #-}
 settings' = unsafePerformIO $ do
   dirs <- getDirs
-  newIORef Settings { cache      = True
+  newIORef $ AppState (Settings { cache      = True
-                     , noVerify   = False
+                                , noVerify   = False
-                     , keepDirs   = Never
+                                , keepDirs   = Never
-                     , downloader = Curl
+                                , downloader = Curl
-                     , verbose    = False
+                                , verbose    = False
-                     , ..
+                                , urlSource  = GHCupURL
-                     }
+                                , ..
+                                })
+                      dirs
+                      defaultKeyBindings
+
 
 
 logger' :: IORef LoggerConfig
@@ -348,32 +509,40 @@ logger' = unsafePerformIO
   )
 
 
-brickMain :: Settings -> Maybe URI -> LoggerConfig -> GHCupDownloads -> PlatformRequest -> IO ()
+brickMain :: AppState
-brickMain s muri l av pfreq' = do
+          -> LoggerConfig
-  writeIORef uri'      muri
+          -> GHCupDownloads
+          -> PlatformRequest
+          -> IO ()
+brickMain s l av pfreq' = do
   writeIORef settings' s
   -- logger interpreter
   writeIORef logger'   l
   let runLogger = myLoggerT l
 
-  eApps <- getAppState (Just av) pfreq'
+  eAppData <- getAppData (Just av) pfreq'
-  case eApps of
+  case eAppData of
-    Right as -> defaultMain app (selectLatest as) $> ()
+    Right ad ->
-    Left  e  -> do
+      defaultMain
+          app
+          (BrickState ad
+                    defaultAppSettings
+                    (constructList ad defaultAppSettings Nothing)
+                    (keyBindings s)
+
+          )
+        $> ()
+    Left e -> do
       runLogger ($(logError) [i|Error building app state: #{show e}|])
       exitWith $ ExitFailure 2
- where
-  selectLatest :: AppState -> AppState
-  selectLatest AppState {..} =
-    (\ix -> AppState { lr = listMoveTo ix lr, .. })
-      . fromJust
-      . V.findIndex (\ListResult {..} -> lTool == GHC && Latest `elem` lTag)
-      $ (listElements lr)
 
 
-getAppState :: Maybe GHCupDownloads -> PlatformRequest -> IO (Either String AppState)
+defaultAppSettings :: BrickSettings
-getAppState mg pfreq' = do
+defaultAppSettings = BrickSettings { showAll = False }
-  muri     <- readIORef uri'
+
+
+getDownloads' :: IO (Either String GHCupDownloads)
+getDownloads' = do
   settings <- readIORef settings'
   l        <- readIORef logger'
   let runLogger = myLoggerT l
@@ -381,14 +550,30 @@ getAppState mg pfreq' = do
   r <-
     runLogger
     . flip runReaderT settings
-    . runE
+    . runE @'[JSONError , DownloadFailed , FileDoesNotExistError]
-      @'[JSONError, DownloadFailed, FileDoesNotExistError]
+    $ fmap _ghcupDownloads
-    $ do
+    $ liftE
-        dls <- maybe (fmap _ghcupDownloads $ liftE $ getDownloadsF (maybe GHCupURL OwnSource muri)) pure mg
+    $ getDownloadsF (urlSource . GT.settings $ settings)
-
-        lV <- lift $ listVersions dls Nothing Nothing pfreq'
-        pure $ (AppState (list "Tool versions" (V.fromList lV) 1) dls pfreq')
 
   case r of
     VRight a -> pure $ Right a
     VLeft  e -> pure $ Left [i|#{e}|]
+
+
+getAppData :: Maybe GHCupDownloads
+           -> PlatformRequest
+           -> IO (Either String BrickData)
+getAppData mg pfreq' = do
+  settings <- readIORef settings'
+  l        <- readIORef logger'
+  let runLogger = myLoggerT l
+
+  r <- maybe getDownloads' (pure . Right) mg
+
+  runLogger . flip runReaderT settings $ do
+    case r of
+      Right dls -> do
+        lV <- listVersions dls Nothing Nothing pfreq'
+        pure $ Right $ (BrickData (reverse lV) dls pfreq')
+      Left e -> pure $ Left [i|#{e}|]
+

app/ghcup/Main.hs

@@ -81,12 +81,12 @@ import qualified Text.Megaparsec.Char          as MPC
 data Options = Options
   {
   -- global options
-    optVerbose   :: Bool
+    optVerbose   :: Maybe Bool
-  , optCache     :: Bool
+  , optCache     :: Maybe Bool
   , optUrlSource :: Maybe URI
-  , optNoVerify  :: Bool
+  , optNoVerify  :: Maybe Bool
-  , optKeepDirs  :: KeepDirs
+  , optKeepDirs  :: Maybe KeepDirs
-  , optsDownloader :: Downloader
+  , optsDownloader :: Maybe Downloader
   -- commands
   , optCommand   :: Command
   }
@@ -122,6 +122,7 @@ data InstallOptions = InstallOptions
   { instVer      :: Maybe ToolVersion
   , instPlatform :: Maybe PlatformRequest
   , instBindist  :: Maybe URI
+  , instSet      :: Bool
   }
 
 data SetCommand = SetGHC SetOptions
@@ -158,6 +159,7 @@ data GHCCompileOptions = GHCCompileOptions
   , patchDir     :: Maybe (Path Abs)
   , crossTarget  :: Maybe Text
   , addConfArgs  :: [Text]
+  , setCompile   :: Bool
   }
 
 data CabalCompileOptions = CabalCompileOptions
@@ -180,13 +182,48 @@ data ChangeLogOptions = ChangeLogOptions
   }
 
 
+-- https://github.com/pcapriotti/optparse-applicative/issues/148
+
+-- | A switch that can be enabled using --foo and disabled using --no-foo.
+--
+-- The option modifier is applied to only the option that is *not* enabled
+-- by default. For example:
+--
+-- > invertableSwitch "recursive" True (help "do not recurse into directories")
+-- 
+-- This example makes --recursive enabled by default, so 
+-- the help is shown only for --no-recursive.
+invertableSwitch 
+    :: String              -- ^ long option
+    -> Char                -- ^ short option for the non-default option
+    -> Bool                -- ^ is switch enabled by default?
+    -> Mod FlagFields Bool -- ^ option modifier
+    -> Parser (Maybe Bool)
+invertableSwitch longopt shortopt defv optmod = invertableSwitch' longopt shortopt defv
+    (if defv then mempty else optmod)
+    (if defv then optmod else mempty)
+
+-- | Allows providing option modifiers for both --foo and --no-foo.
+invertableSwitch'
+    :: String              -- ^ long option (eg "foo")
+    -> Char                -- ^ short option for the non-default option
+    -> Bool                -- ^ is switch enabled by default?
+    -> Mod FlagFields Bool -- ^ option modifier for --foo
+    -> Mod FlagFields Bool -- ^ option modifier for --no-foo
+    -> Parser (Maybe Bool)
+invertableSwitch' longopt shortopt defv enmod dismod = optional
+    ( flag' True (enmod <> long longopt <> if defv then mempty else short shortopt)
+    <|> flag' False (dismod <> long nolongopt <> if defv then short shortopt else mempty)
+    )
+  where
+    nolongopt = "no-" ++ longopt
+
+
 opts :: Parser Options
 opts =
   Options
-    <$> switch (short 'v' <> long "verbose" <> help "Enable verbosity")
+    <$> invertableSwitch "verbose" 'v' False (help "Enable verbosity (default: disabled)")
-    <*> switch
+    <*> invertableSwitch "cache" 'c' False (help "Cache downloads in ~/.ghcup/cache (default: disabled)")
-          (short 'c' <> long "cache" <> help "Cache downloads in ~/.ghcup/cache"
-          )
     <*> (optional
           (option
             (eitherReader parseUri)
@@ -198,35 +235,29 @@ opts =
             )
           )
         )
-    <*> switch
+    <*> (fmap . fmap) not (invertableSwitch "verify" 'n' True (help "Disable tarball checksum verification (default: enabled)"))
-          (short 'n' <> long "no-verify" <> help
+    <*> optional (option
-            "Skip tarball checksum verification"
-          )
-    <*> option
           (eitherReader keepOnParser)
           (  long "keep"
           <> metavar "<always|errors|never>"
           <> help
                "Keep build directories? (default: errors)"
-          <> value Errors
           <> hidden
-          )
+          ))
-    <*> option
+    <*> optional (option
           (eitherReader downloaderParser)
           (  long "downloader"
 #if defined(INTERNAL_DOWNLOADER)
           <> metavar "<internal|curl|wget>"
           <> help
           "Downloader to use (default: internal)"
-          <> value Internal
 #else
           <> metavar "<curl|wget>"
           <> help
           "Downloader to use (default: curl)"
-          <> value Curl
 #endif
           <> hidden
-          )
+          ))
     <*> com
  where
   parseUri s' =
@@ -343,20 +374,20 @@ com =
   installToolFooter = [s|Discussion:
   Installs GHC or cabal. When no command is given, installs GHC
   with the specified version/tag.
-  It is recommended to always specify a subcommand ('ghc' or 'cabal').|]
+  It is recommended to always specify a subcommand (ghc/cabal/hls).|]
 
   setFooter :: String
   setFooter = [s|Discussion:
   Sets the currently active GHC or cabal version. When no command is given,
   defaults to setting GHC with the specified version/tag (if no tag
   is given, sets GHC to 'recommended' version).
-  It is recommended to always specify a subcommand ('ghc' or 'cabal').|]
+  It is recommended to always specify a subcommand (ghc/cabal/hls).|]
 
   rmFooter :: String
   rmFooter = [s|Discussion:
   Remove the given GHC or cabal version. When no command is given,
   defaults to removing GHC with the specified version.
-  It is recommended to always specify a subcommand ('ghc' or 'cabal').|]
+  It is recommended to always specify a subcommand (ghc/cabal/hls).|]
 
   changeLogFooter :: String
   changeLogFooter = [s|Discussion:
@@ -441,7 +472,7 @@ Examples:
 
 installOpts :: Parser InstallOptions
 installOpts =
-  (\p (u, v) -> InstallOptions v p u)
+  (\p (u, v) b -> InstallOptions v p u b)
     <$> (optional
           (option
             (eitherReader platformParser)
@@ -466,6 +497,12 @@ installOpts =
             )
         <|> ((,) <$> pure Nothing <*> optional toolVersionArgument)
         )
+    <*> flag
+          False
+          True
+          (long "set" <> help
+            "Set as active version after install"
+          )
 
 
 setParser :: Parser (Either SetCommand SetOptions)
@@ -635,7 +672,7 @@ Examples:
 
 ghcCompileOpts :: Parser GHCCompileOptions
 ghcCompileOpts =
-  (\CabalCompileOptions {..} crossTarget addConfArgs -> GHCCompileOptions { .. }
+  (\CabalCompileOptions {..} crossTarget addConfArgs setCompile -> GHCCompileOptions { .. }
     )
     <$> cabalCompileOpts
     <*> (optional
@@ -647,6 +684,12 @@ ghcCompileOpts =
           )
         )
     <*> many (argument str (metavar "CONFIGURE_ARGS" <> help "Additional arguments to configure, prefix with '-- ' (longopts)"))
+    <*> flag
+          False
+          True
+          (long "set" <> help
+            "Set as active version after install"
+          )
 
 cabalCompileOpts :: Parser CabalCompileOptions
 cabalCompileOpts =
@@ -709,9 +752,9 @@ cabalCompileOpts =
 
 
 toolVersionParser :: Parser ToolVersion
-toolVersionParser = verP <|> toolP
+toolVersionParser = verP' <|> toolP
  where
-  verP = ToolVersion <$> versionParser
+  verP' = ToolVersion <$> versionParser
   toolP =
     ToolTag
       <$> (option
@@ -839,32 +882,52 @@ 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
 bindistParser = first show . parseURI strictURIParserOptions . UTF8.fromString
 
 
-toSettings :: Options -> IO Settings
+toSettings :: Options -> IO AppState
-toSettings Options {..} = do
+toSettings options = do
-  let cache      = optCache
-      noVerify   = optNoVerify
-      keepDirs   = optKeepDirs
-      downloader = optsDownloader
-      verbose    = optVerbose
   dirs <- getDirs
-  pure $ Settings { .. }
+  userConf <- runE @'[ JSONError ] ghcupConfigFile >>= \case
+    VRight r -> pure r
+    VLeft (V (JSONDecodeError e)) -> do
+      B.hPut stderr ("Error decoding config file: " <> (E.encodeUtf8 . T.pack . show $ e))
+      pure defaultUserSettings
+    _ -> do
+      die "Unexpected error!"
+  pure $ mergeConf options dirs userConf
+ where
+   mergeConf :: Options -> Dirs -> UserSettings -> AppState
+   mergeConf (Options {..}) dirs (UserSettings {..}) =
+     let cache       = fromMaybe (fromMaybe False uCache) optCache
+         noVerify    = fromMaybe (fromMaybe False uNoVerify) optNoVerify
+         verbose     = fromMaybe (fromMaybe False uVerbose) optVerbose
+         keepDirs    = fromMaybe (fromMaybe Errors uKeepDirs) optKeepDirs
+         downloader  = fromMaybe (fromMaybe defaultDownloader uDownloader) optsDownloader
+         keyBindings = maybe defaultKeyBindings mergeKeys uKeyBindings
+         urlSource   = maybe (fromMaybe GHCupURL uUrlSource) OwnSource optUrlSource
+     in AppState (Settings {..}) dirs keyBindings
+#if defined(INTERNAL_DOWNLOADER)
+   defaultDownloader = Internal
+#else
+   defaultDownloader = Curl
+#endif
+   mergeKeys :: UserKeyBindings -> KeyBindings
+   mergeKeys UserKeyBindings {..} =
+     let KeyBindings {..} = defaultKeyBindings
+     in KeyBindings {
+           bUp = fromMaybe bUp kUp
+         , bDown = fromMaybe bDown kDown
+         , bQuit = fromMaybe bQuit kQuit
+         , bInstall = fromMaybe bInstall kInstall
+         , bUninstall = fromMaybe bUninstall kUninstall
+         , bSet = fromMaybe bSet kSet
+         , bChangelog = fromMaybe bChangelog kChangelog
+         , bShowAll = fromMaybe bShowAll kShowAll
+         }
 
 
 upgradeOptsP :: Parser UpgradeOpts
@@ -931,6 +994,7 @@ main = do
 ENV variables:
   * TMPDIR: where ghcup does the work (unpacking, building, ...)
   * GHCUP_INSTALL_BASE_PREFIX: the base of ghcup (default: $HOME)
+  * GHCUP_USE_XDG_DIRS: set to anything to use XDG style directories
 
 Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
@@ -940,15 +1004,15 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
             (footerDoc (Just $ text main_footer))
       )
     >>= \opt@Options {..} -> do
-          settings@Settings{dirs = Dirs{..}, ..} <- toSettings opt
+          appstate@AppState{dirs = Dirs{..}, ..} <- toSettings opt
 
           -- create ~/.ghcup dir
           createDirRecursive' baseDir
 
           -- logger interpreter
-          logfile <- flip runReaderT settings $ initGHCupFileLogging [rel|ghcup.log|]
+          logfile <- flip runReaderT appstate $ initGHCupFileLogging [rel|ghcup.log|]
           let loggerConfig = LoggerConfig
-                { lcPrintDebug = optVerbose
+                { lcPrintDebug = verbose settings
                 , colorOutter  = B.hPut stderr
                 , rawOutter    = appendFile logfile
                 }
@@ -959,9 +1023,9 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
           -- Effect interpreters --
           -------------------------
 
-          let runInstTool' settings' =
+          let runInstTool' appstate' =
                 runLogger
-                  . flip runReaderT settings'
+                  . flip runReaderT appstate'
                   . runResourceT
                   . runE
                     @'[ AlreadyInstalled
@@ -980,12 +1044,12 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                       , TarDirDoesNotExist
                       ]
 
-          let runInstTool = runInstTool' settings
+          let runInstTool = runInstTool' appstate
 
           let
             runSetGHC =
               runLogger
-                . flip runReaderT settings
+                . flip runReaderT appstate
                 . runE
                   @'[ FileDoesNotExistError
                     , NotInstalled
@@ -995,7 +1059,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
           let
             runSetCabal =
               runLogger
-                . flip runReaderT settings
+                . flip runReaderT appstate
                 . runE
                   @'[ NotInstalled
                     , TagNotFound
@@ -1004,26 +1068,26 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
           let
             runSetHLS =
               runLogger
-                . flip runReaderT settings
+                . flip runReaderT appstate
                 . runE
                   @'[ NotInstalled
                     , TagNotFound
                     ]
 
-          let runListGHC = runLogger . flip runReaderT settings
+          let runListGHC = runLogger . flip runReaderT appstate
 
           let runRm =
-                runLogger . flip runReaderT settings . runE @'[NotInstalled]
+                runLogger . flip runReaderT appstate . runE @'[NotInstalled]
 
           let runDebugInfo =
                 runLogger
-                  . flip runReaderT settings
+                  . flip runReaderT appstate
                   . runE
                     @'[NoCompatiblePlatform , NoCompatibleArch , DistroNotFound]
 
           let runCompileGHC =
                 runLogger
-                  . flip runReaderT settings
+                  . flip runReaderT appstate
                   . runResourceT
                   . runE
                     @'[ AlreadyInstalled
@@ -1044,7 +1108,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
           let runUpgrade =
                 runLogger
-                  . flip runReaderT settings
+                  . flip runReaderT appstate
                   . runResourceT
                   . runE
                     @'[ DigestError
@@ -1072,10 +1136,10 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
           (GHCupInfo treq dls) <-
             ( runLogger
-              . flip runReaderT settings
+              . flip runReaderT appstate
               . runE @'[JSONError , DownloadFailed, FileDoesNotExistError]
               $ liftE
-              $ getDownloadsF (maybe GHCupURL OwnSource optUrlSource)
+              $ getDownloadsF (urlSource settings)
               )
               >>= \case
                     VRight r -> pure r
@@ -1086,7 +1150,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
           case optCommand of
             Upgrade _ _ -> pure ()
-            _ -> runLogger $ flip runReaderT settings $ checkForUpdates dls pfreq
+            _ -> runLogger $ flip runReaderT appstate $ checkForUpdates dls pfreq
 
 
 
@@ -1099,12 +1163,14 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      Nothing -> runInstTool $ do
                        v <- liftE $ fromVersion dls instVer GHC
                        liftE $ installGHCBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
-                     Just uri -> runInstTool' settings{noVerify = True} $ do
+                       when instSet $ void $ liftE $ setGHC v SetGHCOnly
+                     Just uri -> runInstTool' appstate{ settings = settings {noVerify = True}} $ do
                        v <- liftE $ fromVersion dls instVer GHC
                        liftE $ installGHCBindist
                          (DownloadInfo uri (Just $ RegexDir "ghc-.*") "")
                          (_tvVersion v)
                          (fromMaybe pfreq instPlatform)
+                       when instSet $ void $ liftE $ setGHC v SetGHCOnly
                     )
                     >>= \case
                           VRight _ -> do
@@ -1115,7 +1181,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                               [i|GHC ver #{prettyVer v} already installed, you may want to run 'ghcup rm ghc #{prettyVer v}' first|]
                             pure ExitSuccess
                           VLeft (V (BuildFailed tmpdir e)) -> do
-                            case keepDirs of
+                            case keepDirs settings of
                               Never -> runLogger ($(logError) [i|Build failed with #{e}|])
                               _ -> runLogger ($(logError) [i|Build failed with #{e}
     Check the logs at #{logsDir} and the build directory #{tmpdir} for more clues.
@@ -1140,7 +1206,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                    Nothing -> runInstTool $ do
                      v <- liftE $ fromVersion dls instVer Cabal
                      liftE $ installCabalBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
-                   Just uri -> runInstTool' settings{noVerify = True} $ do
+                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} $ do
                      v <- liftE $ fromVersion dls instVer Cabal
                      liftE $ installCabalBindist
                          (DownloadInfo uri Nothing "")
@@ -1173,7 +1239,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                    Nothing -> runInstTool $ do
                      v <- liftE $ fromVersion dls instVer HLS
                      liftE $ installHLSBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
-                   Just uri -> runInstTool' settings{noVerify = True} $ do
+                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} $ do
                      v <- liftE $ fromVersion dls instVer HLS
                      liftE $ installHLSBindist
                          (DownloadInfo uri Nothing "")
@@ -1272,7 +1338,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
           res <- case optCommand of
 #if defined(BRICK)
-            Interactive -> liftIO $ brickMain settings 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.|])
@@ -1317,14 +1383,17 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                         pure $ ExitFailure 8
 
             Compile (CompileGHC GHCCompileOptions {..}) ->
-              (runCompileGHC $ liftE $ compileGHC dls
+              (runCompileGHC $ do
-                                                  (GHCTargetVersion crossTarget targetVer)
+                liftE $ compileGHC dls
-                                                  bootstrapGhc
+                            (GHCTargetVersion crossTarget targetVer)
-                                                  jobs
+                            bootstrapGhc
-                                                  buildConfig
+                            jobs
-                                                  patchDir
+                            buildConfig
-                                                  addConfArgs
+                            patchDir
-                                                  pfreq
+                            addConfArgs
+                            pfreq
+                when setCompile $ void $ liftE
+                  $ setGHC (GHCTargetVersion crossTarget targetVer) SetGHCOnly
                 )
                 >>= \case
                       VRight _ -> do
@@ -1336,7 +1405,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                           [i|GHC ver #{prettyVer v} already installed, you may want to run 'ghcup rm ghc #{prettyVer v}' first|]
                         pure ExitSuccess
                       VLeft (V (BuildFailed tmpdir e)) -> do
-                        case keepDirs of
+                        case keepDirs settings of
                           Never -> runLogger ($(logError) [i|Build failed with #{e}
 Check the logs at #{logsDir}|])
                           _ -> runLogger ($(logError) [i|Build failed with #{e}
@@ -1480,7 +1549,7 @@ printListResult raw lr = do
                      , case lCross of
                        Nothing -> T.unpack . prettyVer $ lVer
                        Just c  -> T.unpack (c <> "-" <> prettyVer lVer)
-                     , intercalate "," $ (fmap printTag $ sort lTag)
+                     , intercalate "," $ (filter (/= "") . fmap printTag $ sort lTag)
                      , intercalate ","
                      $  (if hlsPowered
                           then [color' Green "hls-powered"]
@@ -1507,6 +1576,7 @@ printListResult raw lr = do
   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
@@ -1601,7 +1671,14 @@ printListResult raw lr = do
       | otherwise                        -> 1
 
 
-checkForUpdates :: (MonadReader Settings m, MonadCatch m, MonadLogger m, MonadThrow m, MonadIO m, MonadFail m, MonadLogger m)
+checkForUpdates :: ( MonadReader AppState m
+                   , MonadCatch m
+                   , MonadLogger m
+                   , MonadThrow m
+                   , MonadIO m
+                   , MonadFail m
+                   , MonadLogger m
+                   )
                 => GHCupDownloads
                 -> PlatformRequest
                 -> m ()

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.10"
+	_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
@@ -188,7 +199,30 @@ printf "\\033[0;35m%s\\033[0m\\n" ""
 printf "\\033[0;35m%s\\033[0m\\n" "Installation done!"
 printf "\\033[0;35m%s\\033[0m\\n" ""
 
+
 if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+	printf "\\033[0;35m%s\\033[0m\\n" "Do you want to install haskell-language-server (HLS) now?"
+	printf "\\033[0;35m%s\\033[0m\\n" "HLS is a language-server that provides IDE-like functionality"
+	printf "\\033[0;35m%s\\033[0m\\n" "and can integrate with different editors, such as Vim, Emacs, VS Code, Atom, ..."
+	printf "\\033[0;35m%s\\033[0m\\n" "Also see https://github.com/haskell/haskell-language-server/blob/master/README.md"
+	printf "\\033[0;35m%s\\033[0m\\n" ""
+	printf "\\033[0;35m%s\\033[0m\\n" "Answer with YES or NO and press ENTER."
+	printf "\\033[0;35m%s\\033[0m\\n" ""
+
+	while true; do
+		read -r hls_answer </dev/tty
+
+		case $hls_answer in
+			[Yy]*)
+				eghcup --cache install hls
+				break ;;
+			[Nn]*)
+				break ;;
+			*)
+				echo "Please type YES or NO and press enter.";;
+		esac
+	done
+
     echo "In order to run ghc and cabal, you need to adjust your PATH variable."
     echo "You may want to source '$GHCUP_DIR/env' in your shell"
     echo "configuration to do so (e.g. ~/.bashrc)."
@@ -238,7 +272,20 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 							echo "test -f $GHCUP_DIR/env ; and set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH" >> "${GHCUP_PROFILE_FILE}"
 						fi
 						break ;;
-					*)
+					bash)
+						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
+							echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+						fi
+						case "$(uname -s)" in
+							"Darwin"|"darwin")
+								if ! grep -q "ghcup-env" "${HOME}/.bash_profile" ; then
+									echo "[[ -f ~/.bashrc ]] && source ~/.bashrc # ghcup-env" >> "${HOME}/.bash_profile"
+								fi
+								;;
+						esac
+						break ;;
+
+					zsh)
 						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
 							echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
 						fi

cabal.ghc884.project

@@ -0,0 +1,47 @@
+-- Generated by stackage-to-hackage
+
+index-state: 2020-10-24T20:53:55Z
+
+with-compiler: ghc-8.8.4
+
+packages:
+    ./
+  , 3rdparty/lzma/
+  , 3rdparty/lzma-clib/
+  , 3rdparty/zlib/
+
+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-directory
+            hpath-io
+
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/text-conversions.git
+    tag: 9abf0e5e5664a3178367597c32db19880477a53c
+
+allow-older: *
+allow-newer: *
+
+package lzma
+    ghc-options: -O2
+
+package lzma-clib
+    ghc-options: -O2
+
+package zlib
+    ghc-options: -O2
+
+package ghcup
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+package streamly
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16

cabal.project

@@ -20,12 +20,6 @@ source-repository-package
     tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
     subdir: hpath-directory
 
--- https://github.com/cjdev/text-conversions/pull/10
-source-repository-package
-    type: git
-    location: https://github.com/hasufell/text-conversions.git
-    tag: 9abf0e5e5664a3178367597c32db19880477a53c
-
 optimization: 2
 
 package streamly

config.yaml

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

ghcup-0.0.2.yaml

@@ -1287,32 +1287,32 @@ ghcupDownloads:
             unknown_versioning:
               dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.2.0.0/cabal-install-3.2.0.0-i386-unknown-linux.tar.xz
               dlHash: 2b3ac28549916de5f3379241797eaf60e84b6c001f2abbe73d9fadbbaf768e93
-    3.4.0.0-rc3:
+    3.4.0.0-rc4:
       viTags:
       - Prerelease
       viChangeLog: https://github.com/haskell/cabal/blob/master/release-notes/cabal-install-3.4.0.0.md
       viArch:
         A_64:
           Linux_Ubuntu:
-            unknown_versioning: &cabal-3400rc3-ubuntu
+            unknown_versioning: &cabal-3400rc4-ubuntu
-              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc3/cabal-install-3.4.0.0-x86_64-ubuntu-16.04.tar.xz
+              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-ubuntu-16.04.tar.xz
-              dlHash: a97f0362b8cdc78ba4a7891f8b288082dc11e20c64b1b3c8e6c2bd3766446d10
+              dlHash: a1be168876816a624b206c55596d9bb5f442541c889ee2438d664698122b9ffe
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc3/cabal-install-3.4.0.0-x86_64-alpine-3.11.6-static-noofd.tar.xz
+              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-alpine-3.11.6-static-noofd.tar.xz
-              dlHash: a82c7dc7e46da823f6a982465b9b29e0640a5ce2e5b573d3dd55a47e20740305
+              dlHash: 49dab6684483594e4c7c3e561ec477268002605253ad34701b471277efbe91bc
           Linux_UnknownLinux:
-            unknown_versioning: *cabal-3400rc3-ubuntu
+            unknown_versioning: *cabal-3400rc4-ubuntu
           Darwin:
             unknown_versioning:
-              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc3/cabal-install-3.4.0.0-x86_64-darwin-sierra.tar.xz
+              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-darwin-sierra.tar.xz
-              dlHash: 4553eaea3031c09ab5156af8d4a62bf1ecbbea2c3b57a876f267cbf4b5a15658
+              dlHash: a3f809a3388e90b9fdf52444e30ea9aad3894e2cbe53c37fc3311ceb106eda9e
           FreeBSD:
             unknown_versioning:
-              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc3/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
+              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: 44e25e0b0d15361acb369f4bf2206a39d2432a08fb922cc40a9b8a045d0a3a6f
+              dlHash: 9705e16d03497b46be4ad477e6c64d10890af853eafa8a9adf6dba89aa9e05f7
   GHCup:
-    0.1.10:
+    0.1.11:
       viTags:
       - Recommended
       - Latest
@@ -1322,39 +1322,22 @@ ghcupDownloads:
         A_64:
           Linux_UnknownLinux:
             unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.10/x86_64-linux-ghcup-0.1.10
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-linux-ghcup-0.1.11
-              dlHash: 87661bd127f857b990174ac8d96ad4bd629865306b2058c8cc64d3b36ed317c9
+              dlHash: 99d97c9a1dce76892001e5cffd50cc23bf804f2282998c546d1b965aa2179699
           Darwin:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.10/x86_64-apple-darwin-ghcup-0.1.10
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-apple-darwin-ghcup-0.1.11
-              dlHash: e71666fde6a7700f307e1a55720859d3a042fe27c68ff32f3d1181f4436b7391
+              dlHash: 4b91dcd9bfdc40534156b8fadea3f317b3c44af1255169895f4911a221f819c6
           FreeBSD:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.10/x86_64-portbld-freebsd-ghcup-0.1.10
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-portbld-freebsd-ghcup-0.1.11
-              dlHash: b5ef1b0454f1a9c5a62b378c1e9c48c2b794d64a22086adf482b064dfb34e68d
+              dlHash: 6f04ce98d3f3eb9299ce74f8264aa956f0dc38a64a3bd12ee048b7f146e9e1b4
           Linux_Alpine:
             unknown_versioning: *ghcup-64
         A_32:
           Linux_UnknownLinux:
             unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.10/i386-linux-ghcup-0.1.10
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/i386-linux-ghcup-0.1.11
-              dlHash: 50ac43199b64bc0724400b0a3db674bef3ec53cf6d41acc04a2c4ca8557e534f
+              dlHash: ec339e4c2b8b4d502f66a03c0d3f112cb68cd922dd3c4a6f66323628cf6a76c2
           Linux_Alpine:
             unknown_versioning: *ghcup-32
-
-  HLS:
-    0.4.0:
-      viTags:
-        - Recommended
-        - Latest
-      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#040
-      viArch:
-        A_64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.4.0/haskell-language-server-Linux-0.4.0.tar.gz
-              dlHash: 325b21b38a5e570f00b983885e8ec1eadcb5504a29b28ea4cbe1b85b32058f6d
-          Darwin:
-            unknown_versioning:
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.4.0/haskell-language-server-macOS-0.4.0.tar.gz
-              dlHash: 06a23f1495086438e9676213f7aeddbbc382014ad8016ed7c8ad241a2a15fcfe

ghcup.cabal

@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               ghcup
-version:            0.1.11
+version:            0.1.12
 synopsis:           ghc toolchain installer as an exe/library
 description:
   A rewrite of the shell script ghcup, for providing
@@ -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
@@ -72,6 +72,9 @@ common bz2
 common case-insensitive
   build-depends: case-insensitive >=1.2.1.0
 
+common casing
+  build-depends: casing >=0.1.4.1
+
 common concurrent-output
   build-depends: concurrent-output >=1.10.11
 
@@ -226,7 +229,7 @@ common vector
   build-depends: vector >=0.12
 
 common versions
-  build-depends: versions >=3.5
+  build-depends: versions >=4.0.1
 
 common vty
   build-depends: vty >=5.28.2
@@ -266,6 +269,7 @@ library
     , bytestring
     , bz2
     , case-insensitive
+    , casing
     , concurrent-output
     , containers
     , cryptohash-sha256
@@ -307,6 +311,7 @@ library
     , utf8-string
     , vector
     , versions
+    , vty
     , word8
     , yaml
     , zlib

hie.yaml

@@ -1,6 +1,19 @@
 cradle:
   cabal:
-    - path: "."
+    - path: "./lib"
-      component: "ghcup:lib:ghcup"
+      component: "lib:ghcup"
-    - path: "."
+
+    - path: "./app/ghcup/Main.hs"
       component: "ghcup:exe:ghcup"
+
+    - path: "./app/ghcup/BrickMain.hs"
+      component: "ghcup:exe:ghcup"
+
+    - path: "./app/ghcup-gen/Main.hs"
+      component: "ghcup:exe:ghcup-gen"
+
+    - path: "./app/ghcup-gen/Validate.hs"
+      component: "ghcup:exe:ghcup-gen"
+
+    - path: "./test"
+      component: "ghcup:test:ghcup-test"

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
@@ -99,7 +99,7 @@ import qualified Data.Text.Encoding            as E
 installGHCBindist :: ( MonadFail m
                      , MonadMask m
                      , MonadCatch m
-                     , MonadReader Settings m
+                     , MonadReader AppState m
                      , MonadLogger m
                      , MonadResource m
                      , MonadIO m
@@ -134,15 +134,28 @@ 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
                     , MonadCatch m
-                    , MonadReader Settings m
+                    , MonadReader AppState m
                     , MonadThrow m
                     , MonadLogger m
                     , MonadIO m
@@ -178,7 +191,7 @@ installPackedGHC dl msubdir inst ver pfreq@(PlatformRequest {..}) = do
 
 -- | Install an unpacked GHC distribution. This only deals with the GHC
 -- build system and nothing else.
-installUnpackedGHC :: ( MonadReader Settings m
+installUnpackedGHC :: ( MonadReader AppState m
                       , MonadThrow m
                       , MonadLogger m
                       , MonadIO m
@@ -214,7 +227,7 @@ installUnpackedGHC path inst ver (PlatformRequest {..}) = do
 installGHCBin :: ( MonadFail m
                  , MonadMask m
                  , MonadCatch m
-                 , MonadReader Settings m
+                 , MonadReader AppState m
                  , MonadLogger m
                  , MonadResource m
                  , MonadIO m
@@ -246,7 +259,7 @@ installGHCBin bDls ver pfreq = do
 -- argument instead of looking it up from 'GHCupDownloads'.
 installCabalBindist :: ( MonadMask m
                        , MonadCatch m
-                       , MonadReader Settings m
+                       , MonadReader AppState m
                        , MonadLogger m
                        , MonadResource m
                        , MonadIO m
@@ -273,7 +286,7 @@ installCabalBindist :: ( MonadMask m
 installCabalBindist dlinfo ver (PlatformRequest {..}) = do
   lift $ $(logDebug) [i|Requested to install cabal version #{ver}|]
 
-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState {dirs = Dirs {..}} <- lift ask
 
   whenM
       (lift (cabalInstalled ver) >>= \a -> liftIO $
@@ -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
@@ -328,7 +341,7 @@ installCabalBindist dlinfo ver (PlatformRequest {..}) = do
 -- the latest installed version.
 installCabalBin :: ( MonadMask m
                    , MonadCatch m
-                   , MonadReader Settings m
+                   , MonadReader AppState m
                    , MonadLogger m
                    , MonadResource m
                    , MonadIO m
@@ -361,7 +374,7 @@ installCabalBin bDls ver pfreq = do
 -- argument instead of looking it up from 'GHCupDownloads'.
 installHLSBindist :: ( MonadMask m
                      , MonadCatch m
-                     , MonadReader Settings m
+                     , MonadReader AppState m
                      , MonadLogger m
                      , MonadResource m
                      , MonadIO m
@@ -388,7 +401,7 @@ installHLSBindist :: ( MonadMask m
 installHLSBindist dlinfo ver (PlatformRequest {..}) = do
   lift $ $(logDebug) [i|Requested to install hls version #{ver}|]
 
-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState {dirs = Dirs {..}} <- lift ask
 
   whenM (lift (hlsInstalled ver))
     $ (throwE $ AlreadyInstalled HLS ver)
@@ -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,14 +458,14 @@ 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\>@
 -- into @~\/.ghcup\/bin/@, as well as @haskell-languager-server-wrapper@.
 installHLSBin :: ( MonadMask m
                  , MonadCatch m
-                 , MonadReader Settings m
+                 , MonadReader AppState m
                  , MonadLogger m
                  , MonadResource m
                  , MonadIO m
@@ -498,7 +511,7 @@ installHLSBin bDls ver pfreq = do
 --
 -- Additionally creates a @~\/.ghcup\/share -> ~\/.ghcup\/ghc\/\<ver\>\/share symlink@
 -- for 'SetGHCOnly' constructor.
-setGHC :: ( MonadReader Settings m
+setGHC :: ( MonadReader AppState m
           , MonadLogger m
           , MonadThrow m
           , MonadFail m
@@ -515,15 +528,15 @@ setGHC ver sghc = do
   whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC (ver ^. tvVersion % to prettyVer)))
 
   -- symlink destination
-  Settings { dirs = Dirs {..} } <- lift ask
+  AppState { dirs = Dirs {..} } <- lift ask
   liftIO $ createDirRecursive' binDir
 
   -- first delete the old symlinks (this fixes compatibility issues
   -- 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
@@ -556,12 +569,12 @@ setGHC ver sghc = do
 
  where
 
-  symlinkShareDir :: (MonadReader Settings m, MonadIO m, MonadLogger m)
+  symlinkShareDir :: (MonadReader AppState m, MonadIO m, MonadLogger m)
                   => Path Abs
                   -> ByteString
                   -> m ()
   symlinkShareDir ghcdir verBS = do
-    Settings { dirs = Dirs {..} } <- ask
+    AppState { dirs = Dirs {..} } <- ask
     let destdir = baseDir
     case sghc of
       SetGHCOnly -> do
@@ -579,7 +592,7 @@ setGHC ver sghc = do
 
 
 -- | Set the @~\/.ghcup\/bin\/cabal@ symlink.
-setCabal :: (MonadReader Settings m, MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
+setCabal :: (MonadReader AppState m, MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
          => Version
          -> Excepts '[NotInstalled] m ()
 setCabal ver = do
@@ -587,7 +600,7 @@ setCabal ver = do
   targetFile <- parseRel ("cabal-" <> verBS)
 
   -- symlink destination
-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState {dirs = Dirs {..}} <- lift ask
   liftIO $ createDirRecursive' binDir
 
   whenM (liftIO $ fmap not $ doesFileExist (binDir </> targetFile))
@@ -613,7 +626,7 @@ setCabal ver = do
 
 -- | Set the haskell-language-server symlinks.
 setHLS :: ( MonadCatch m
-          , MonadReader Settings m
+          , MonadReader AppState m
           , MonadLogger m
           , MonadThrow m
           , MonadFail m
@@ -622,7 +635,7 @@ setHLS :: ( MonadCatch m
        => Version
        -> Excepts '[NotInstalled] m ()
 setHLS ver = do
-  Settings { dirs = Dirs {..} } <- lift ask
+  AppState { dirs = Dirs {..} } <- lift ask
   liftIO $ createDirRecursive' binDir
 
   -- Delete old symlinks, since these might have different ghc versions than the
@@ -703,7 +716,7 @@ listVersions :: ( MonadCatch m
                 , MonadThrow m
                 , MonadLogger m
                 , MonadIO m
-                , MonadReader Settings m
+                , MonadReader AppState m
                 )
              => GHCupDownloads
              -> Maybe Tool
@@ -736,7 +749,7 @@ listVersions av lt criteria pfreq = do
       pure (ghcvers <> cabalvers <> hlsvers <> ghcupvers)
 
  where
-  strayGHCs :: (MonadCatch m, MonadReader Settings m, MonadThrow m, MonadLogger m, MonadIO m)
+  strayGHCs :: (MonadCatch m, MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m)
             => Map.Map Version [Tag]
             -> m [ListResult]
   strayGHCs avTools = do
@@ -778,7 +791,7 @@ listVersions av lt criteria pfreq = do
           [i|Could not parse version of stray directory #{toFilePath e}|]
         pure Nothing
 
-  strayCabals :: (MonadReader Settings m, MonadCatch m, MonadThrow m, MonadLogger m, MonadIO m)
+  strayCabals :: (MonadReader AppState m, MonadCatch m, MonadThrow m, MonadLogger m, MonadIO m)
             => Map.Map Version [Tag]
             -> m [ListResult]
   strayCabals avTools = do
@@ -806,7 +819,7 @@ listVersions av lt criteria pfreq = do
           [i|Could not parse version of stray directory #{toFilePath e}|]
         pure Nothing
 
-  strayHLS :: (MonadReader Settings m, MonadCatch m, MonadThrow m, MonadLogger m, MonadIO m)
+  strayHLS :: (MonadReader AppState m, MonadCatch m, MonadThrow m, MonadLogger m, MonadIO m)
            => Map.Map Version [Tag]
            -> m [ListResult]
   strayHLS avTools = do
@@ -835,7 +848,7 @@ listVersions av lt criteria pfreq = do
         pure Nothing
 
   -- NOTE: this are not cross ones, because no bindists
-  toListResult :: (MonadReader Settings m, MonadIO m, MonadCatch m) => Tool -> (Version, [Tag]) -> m ListResult
+  toListResult :: (MonadReader AppState m, MonadIO m, MonadCatch m) => Tool -> (Version, [Tag]) -> m ListResult
   toListResult t (v, tags) = case t of
     GHC -> do
       let lNoBindist = isLeft $ getDownloadInfo GHC v pfreq av
@@ -904,7 +917,7 @@ listVersions av lt criteria pfreq = do
 -- This may leave GHCup without a "set" version.
 -- Will try to fix the ghc-x.y symlink after removal (e.g. to an
 -- older version).
-rmGHCVer :: ( MonadReader Settings m
+rmGHCVer :: ( MonadReader AppState m
             , MonadThrow m
             , MonadLogger m
             , MonadIO m
@@ -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)
@@ -942,7 +956,7 @@ rmGHCVer ver = do
   forM_ v' $ \(mj, mi) -> lift (getGHCForMajor mj mi (_tvTarget ver))
     >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)
 
-  Settings { dirs = Dirs {..} } <- lift ask
+  AppState { dirs = Dirs {..} } <- lift ask
 
   liftIO
     $ hideError doesNotExistErrorType
@@ -952,7 +966,7 @@ rmGHCVer ver = do
 
 -- | Delete a cabal version. Will try to fix the @cabal@ symlink
 -- after removal (e.g. setting it to an older version).
-rmCabalVer :: (MonadReader Settings m, MonadThrow m, MonadLogger m, MonadIO m, MonadFail m, MonadCatch m)
+rmCabalVer :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m, MonadFail m, MonadCatch m)
            => Version
            -> Excepts '[NotInstalled] m ()
 rmCabalVer ver = do
@@ -960,7 +974,7 @@ rmCabalVer ver = do
 
   cSet      <- lift $ cabalSet
 
-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState {dirs = Dirs {..}} <- lift ask
 
   cabalFile <- lift $ parseRel ("cabal-" <> verToBS ver)
   liftIO $ hideError doesNotExistErrorType $ deleteFile (binDir </> cabalFile)
@@ -975,7 +989,7 @@ rmCabalVer ver = do
 
 -- | Delete a hls version. Will try to fix the hls symlinks
 -- after removal (e.g. setting it to an older version).
-rmHLSVer :: (MonadReader Settings m, MonadThrow m, MonadLogger m, MonadIO m, MonadFail m, MonadCatch m)
+rmHLSVer :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m, MonadFail m, MonadCatch m)
          => Version
          -> Excepts '[NotInstalled] m ()
 rmHLSVer ver = do
@@ -983,7 +997,7 @@ rmHLSVer ver = do
 
   isHlsSet      <- lift $ hlsSet
 
-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState {dirs = Dirs {..}} <- lift ask
 
   bins <- lift $ hlsAllBinaries ver
   forM_ bins $ \f -> liftIO $ deleteFile (binDir </> f)
@@ -1008,13 +1022,13 @@ rmHLSVer ver = do
     ------------------
 
 
-getDebugInfo :: (MonadReader Settings m, MonadLogger m, MonadCatch m, MonadIO m)
+getDebugInfo :: (MonadReader AppState m, MonadLogger m, MonadCatch m, MonadIO m)
              => Excepts
                   '[NoCompatiblePlatform , NoCompatibleArch , DistroNotFound]
                   m
                   DebugInfo
 getDebugInfo = do
-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState {dirs = Dirs {..}} <- lift ask
   let diBaseDir  = baseDir
   let diBinDir   = binDir
   diGHCDir       <- lift ghcupGHCBaseDir
@@ -1034,7 +1048,7 @@ getDebugInfo = do
 -- | Compile a GHC from source. This behaves wrt symlinks and installation
 -- the same as 'installGHCBin'.
 compileGHC :: ( MonadMask m
-              , MonadReader Settings m
+              , MonadReader AppState m
               , MonadThrow m
               , MonadResource m
               , MonadLogger m
@@ -1135,7 +1149,7 @@ BUILD_SPHINX_PDF = NO
 HADDOCK_DOCS = NO
 Stage1Only = YES|]
 
-  compileBindist :: ( MonadReader Settings m
+  compileBindist :: ( MonadReader AppState m
                     , MonadThrow m
                     , MonadCatch m
                     , MonadLogger m
@@ -1153,7 +1167,7 @@ Stage1Only = YES|]
     lift $ $(logInfo) [i|configuring build|]
     liftE $ checkBuildConfig
 
-    Settings { dirs = Dirs {..} } <- lift ask
+    AppState { dirs = Dirs {..} } <- lift ask
 
     forM_ patchdir $ \dir -> liftE $ applyPatches dir workdir
 
@@ -1270,7 +1284,7 @@ Stage1Only = YES|]
 -- | Upgrade ghcup and place it in @~\/.ghcup\/bin\/ghcup@,
 -- if no path is provided.
 upgradeGHCup :: ( MonadMask m
-                , MonadReader Settings m
+                , MonadReader AppState m
                 , MonadCatch m
                 , MonadLogger m
                 , MonadThrow m
@@ -1292,7 +1306,7 @@ upgradeGHCup :: ( MonadMask m
                   m
                   Version
 upgradeGHCup dls mtarget force pfreq = do
-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState {dirs = Dirs {..}} <- lift ask
   lift $ $(logInfo) [i|Upgrading GHCup...|]
   let latestVer = fromJust $ getLatest dls GHCup
   when (not force && (latestVer <= pvpToVersion ghcUpVer)) $ throwE NoUpdate
@@ -1305,7 +1319,7 @@ upgradeGHCup dls mtarget force pfreq = do
   handleIO (throwE . CopyError . show) $ liftIO $ copyFile p
                                                            fullDest
                                                            Overwrite
-  lift $ chmod_777 fullDest
+  lift $ chmod_755 fullDest
   pure latestVer
 
 
@@ -1317,7 +1331,7 @@ upgradeGHCup dls mtarget force pfreq = do
 
 -- | Creates @ghc-x.y.z@ and @ghc-x.y@ symlinks. This is used for
 -- both installing from source and bindist.
-postGHCInstall :: ( MonadReader Settings m
+postGHCInstall :: ( MonadReader AppState m
                   , MonadLogger m
                   , MonadThrow m
                   , MonadFail m

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
@@ -83,9 +84,9 @@ import qualified Crypto.Hash.SHA256            as SHA256
 import qualified Data.ByteString               as BS
 import qualified Data.ByteString.Base16        as B16
 import qualified Data.ByteString.Lazy          as L
+import qualified Data.Map.Strict               as M
 #if defined(INTERNAL_DOWNLOADER)
 import qualified Data.CaseInsensitive          as CI
-import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 #endif
 import qualified Data.Text.Encoding            as E
@@ -104,8 +105,8 @@ import qualified System.Posix.RawFilePath.Directory
     ------------------
 
 
--- | Like 'getDownloads', but tries to fall back to
+
--- cached ~/.ghcup/cache/ghcup-<format-ver>.yaml
+-- | Downloads the download information! But only if we need to ;P
 getDownloadsF :: ( FromJSONKey Tool
                  , FromJSONKey Version
                  , FromJSON VersionInfo
@@ -114,7 +115,7 @@ getDownloadsF :: ( FromJSONKey Tool
                  , MonadLogger m
                  , MonadThrow m
                  , MonadFail m
-                 , MonadReader Settings m
+                 , MonadReader AppState m
                  )
               => URLSource
               -> Excepts
@@ -123,17 +124,24 @@ getDownloadsF :: ( FromJSONKey Tool
                    GHCupInfo
 getDownloadsF urlSource = do
   case urlSource of
-    GHCupURL ->
+    GHCupURL -> liftE getBase
-      liftE
+    (OwnSource url) -> do
-        $ handleIO (\_ -> readFromCache)
+      bs <- reThrowAll DownloadFailed $ downloadBS url
-        $ catchE @_ @'[JSONError , FileDoesNotExistError]
+      lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
-            (\(DownloadFailed _) -> readFromCache)
+    (OwnSpec av) -> pure av
-        $ getDownloads urlSource
+    (AddSource (Left ext)) -> do
-    (OwnSource _) -> liftE $ getDownloads urlSource
+      base <- liftE getBase
-    (OwnSpec   _) -> liftE $ getDownloads urlSource
+      pure (mergeGhcupInfo base ext)
+    (AddSource (Right uri)) -> do
+      base <- liftE getBase
+      bsExt <- reThrowAll DownloadFailed $ downloadBS uri
+      ext <- lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bsExt)
+      pure (mergeGhcupInfo base ext)
  where
+  readFromCache :: (MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
+                => Excepts '[JSONError, FileDoesNotExistError] m GHCupInfo
   readFromCache = do
-    Settings {dirs = Dirs {..}} <- lift ask
+    AppState {dirs = Dirs {..}} <- lift ask
     lift $ $(logWarn)
       [i|Could not get download info, trying cached version (this may not be recent!)|]
     let path = view pathL' ghcupURL
@@ -145,32 +153,25 @@ getDownloadsF urlSource = do
       $ readFile yaml_file
     lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
 
+  getBase :: (MonadFail m, MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
+          => Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
+  getBase =
+    handleIO (\_ -> readFromCache)
+    $ catchE @_ @'[JSONError, FileDoesNotExistError]
+        (\(DownloadFailed _) -> readFromCache)
+    $ ((reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed $ smartDl ghcupURL)
+      >>= (liftE . lE' @_ @_ @'[JSONError] JSONDecodeError . bimap show id . Y.decodeEither' . L.toStrict))
 
--- | Downloads the download information! But only if we need to ;P
+  mergeGhcupInfo :: GHCupInfo -- ^ base to merge with
-getDownloads :: ( FromJSONKey Tool
+                 -> GHCupInfo -- ^ extension overwriting the base
-                , FromJSONKey Version
+                 -> GHCupInfo
-                , FromJSON VersionInfo
+  mergeGhcupInfo (GHCupInfo tr base) (GHCupInfo _ ext) =
-                , MonadIO m
+    let new = M.mapWithKey (\k a -> case M.lookup k ext of
-                , MonadCatch m
+                                        Just a' -> M.union a' a
-                , MonadLogger m
+                                        Nothing -> a
-                , MonadThrow m
+                           ) base
-                , MonadFail m
+    in GHCupInfo tr new
-                , MonadReader Settings m
-                )
-             => URLSource
-             -> Excepts '[JSONError , DownloadFailed] m GHCupInfo
-getDownloads urlSource = do
-  lift $ $(logDebug) [i|Receiving download info from: #{urlSource}|]
-  case urlSource of
-    GHCupURL -> do
-      bs <- reThrowAll DownloadFailed $ smartDl ghcupURL
-      lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
-    (OwnSource url) -> do
-      bs <- reThrowAll DownloadFailed $ downloadBS url
-      lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
-    (OwnSpec av) -> pure $ av
 
- where
   -- First check if the json file is in the ~/.ghcup/cache dir
   -- and check it's access time. If it has been accessed within the
   -- last 5 minutes, just reuse it.
@@ -185,7 +186,7 @@ getDownloads urlSource = do
              , MonadIO m1
              , MonadFail m1
              , MonadLogger m1
-             , MonadReader Settings m1
+             , MonadReader AppState m1
              )
           => URI
           -> Excepts
@@ -200,7 +201,7 @@ getDownloads urlSource = do
                m1
                L.ByteString
   smartDl uri' = do
-    Settings {dirs = Dirs {..}} <- lift ask
+    AppState {dirs = Dirs {..}} <- lift ask
     let path = view pathL' uri'
     json_file <- (cacheDir </>) <$> urlBaseName path
     e         <- liftIO $ doesFileExist json_file
@@ -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
@@ -311,7 +324,7 @@ getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
 --
 -- The file must not exist.
 download :: ( MonadMask m
-            , MonadReader Settings m
+            , MonadReader AppState m
             , MonadThrow m
             , MonadLogger m
             , MonadIO m
@@ -383,7 +396,7 @@ downloadCached :: ( MonadMask m
                   , MonadThrow m
                   , MonadLogger m
                   , MonadIO m
-                  , MonadReader Settings m
+                  , MonadReader AppState m
                   )
                => DownloadInfo
                -> Maybe (Path Rel)  -- ^ optional filename
@@ -392,7 +405,7 @@ downloadCached dli mfn = do
   cache <- lift getCache
   case cache of
     True -> do
-      Settings {dirs = Dirs {..}} <- lift ask
+      AppState {dirs = Dirs {..}} <- lift ask
       fn       <- maybe (urlBaseName $ view (dlUri % pathL') dli) pure mfn
       let cachfile = cacheDir </> fn
       fileExists <- liftIO $ doesFileExist cachfile
@@ -416,7 +429,7 @@ downloadCached dli mfn = do
 
 
 -- | This is used for downloading the JSON.
-downloadBS :: (MonadReader Settings m, MonadCatch m, MonadIO m, MonadLogger m)
+downloadBS :: (MonadReader AppState m, MonadCatch m, MonadIO m, MonadLogger m)
            => URI
            -> Excepts
                 '[ FileDoesNotExistError
@@ -473,12 +486,12 @@ downloadBS uri'
 #endif
 
 
-checkDigest :: (MonadIO m, MonadThrow m, MonadLogger m, MonadReader Settings m)
+checkDigest :: (MonadIO m, MonadThrow m, MonadLogger m, MonadReader AppState m)
             => DownloadInfo
             -> Path Abs
             -> Excepts '[DigestError] m ()
 checkDigest dli file = do
-  verify <- lift ask <&> (not . noVerify)
+  verify <- lift ask <&> (not . noVerify . settings)
   when verify $ do
     p' <- toFilePath <$> basename file
     lift $ $(logInfo) [i|verifying digest of: #{p'}|]

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
@@ -21,6 +22,7 @@ import           URI.ByteString
 
 import qualified Data.Text                     as T
 import qualified GHC.Generics                  as GHC
+import qualified Graphics.Vty                  as Vty
 
 
 
@@ -45,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
@@ -69,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.
@@ -96,6 +98,7 @@ data Tag = Latest
          | Recommended
          | Prerelease
          | Base PVP
+         | Old                -- ^ old version are hidden by default in TUI
          | UnknownTag String  -- ^ used for upwardscompat
          deriving (Ord, Eq, GHC.Generic, Show) -- FIXME: manual JSON instance
 
@@ -189,27 +192,82 @@ data TarDir = RealDir (Path Rel)
 data URLSource = GHCupURL
                | OwnSource URI
                | OwnSpec GHCupInfo
+               | AddSource (Either GHCupInfo URI) -- ^ merge with GHCupURL
                deriving (GHC.Generic, Show)
 
 
+data UserSettings = UserSettings
+  { uCache       :: Maybe Bool
+  , uNoVerify    :: Maybe Bool
+  , uVerbose     :: Maybe Bool
+  , uKeepDirs    :: Maybe KeepDirs
+  , uDownloader  :: Maybe Downloader
+  , uKeyBindings :: Maybe UserKeyBindings
+  , uUrlSource   :: Maybe URLSource
+  }
+  deriving (Show, GHC.Generic)
+
+defaultUserSettings :: UserSettings
+defaultUserSettings = UserSettings Nothing Nothing Nothing Nothing Nothing Nothing Nothing
+
+data UserKeyBindings = UserKeyBindings
+  { kUp        :: Maybe Vty.Key
+  , kDown      :: Maybe Vty.Key
+  , kQuit      :: Maybe Vty.Key
+  , kInstall   :: Maybe Vty.Key
+  , kUninstall :: Maybe Vty.Key
+  , kSet       :: Maybe Vty.Key
+  , kChangelog :: Maybe Vty.Key
+  , kShowAll   :: Maybe Vty.Key
+  }
+  deriving (Show, GHC.Generic)
+
+data KeyBindings = KeyBindings
+  { bUp        :: Vty.Key
+  , bDown      :: Vty.Key
+  , bQuit      :: Vty.Key
+  , bInstall   :: Vty.Key
+  , bUninstall :: Vty.Key
+  , bSet       :: Vty.Key
+  , bChangelog :: Vty.Key
+  , bShowAll   :: Vty.Key
+  }
+  deriving (Show, GHC.Generic)
+
+defaultKeyBindings :: KeyBindings
+defaultKeyBindings = KeyBindings
+  { bUp = Vty.KUp
+  , bDown = Vty.KDown
+  , bQuit = Vty.KChar 'q'
+  , bInstall = Vty.KChar 'i'
+  , bUninstall = Vty.KChar 'u'
+  , bSet = Vty.KChar 's'
+  , bChangelog = Vty.KChar 'c'
+  , bShowAll = Vty.KChar 'a'
+  }
+
+data AppState = AppState
+  { settings :: Settings
+  , dirs :: Dirs
+  , keyBindings :: KeyBindings
+  } deriving (Show)
+
 data Settings = Settings
-  { -- set by user
+  { cache      :: Bool
-    cache      :: Bool
   , noVerify   :: Bool
   , keepDirs   :: KeepDirs
   , downloader :: Downloader
   , verbose    :: Bool
-
+  , urlSource  :: URLSource
-    -- set on app start
-  , dirs       :: Dirs
   }
-  deriving Show
+  deriving (Show, GHC.Generic)
 
 data Dirs = Dirs
   { baseDir  :: Path Abs
   , binDir   :: Path Abs
   , cacheDir :: Path Abs
   , logsDir  :: Path Abs
+  , confDir  :: Path Abs
   }
   deriving Show
 
@@ -250,7 +308,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
 
@@ -287,3 +345,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,25 +22,34 @@ Portability : POSIX
 module GHCup.Types.JSON where
 
 import           GHCup.Types
+import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
 
 import           Control.Applicative            ( (<|>) )
 import           Data.Aeson
 import           Data.Aeson.TH
 import           Data.Aeson.Types
+import           Data.List.NonEmpty             ( NonEmpty(..) )
 import           Data.Text.Encoding            as E
 import           Data.Versions
+import           Data.Void
 import           Data.Word8
 import           HPath
 import           URI.ByteString
+import           Text.Casing
 
 import qualified Data.ByteString               as BS
+import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T
+import qualified Graphics.Vty                  as Vty
+import qualified Text.Megaparsec               as MP
+import qualified Text.Megaparsec.Char          as MPC
 
 
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } { fieldLabelModifier = removeLensFieldLabel } ''Architecture
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''LinuxDistro
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Mess
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''MChunk
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Platform
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''SemVer
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
@@ -50,11 +59,18 @@ deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Versio
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''DownloadInfo
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GHCupInfo
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Requirements
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''KeepDirs
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Downloader
+deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''URLSource
+deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "u-") . T.pack . kebab $ str' } ''UserSettings
+deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "k-") . T.pack . kebab $ str' } ''UserKeyBindings
+deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''Vty.Key
 
 instance ToJSON Tag where
   toJSON Latest             = String "Latest"
   toJSON Recommended        = String "Recommended"
   toJSON Prerelease         = String "Prerelease"
+  toJSON Old                = String "old"
   toJSON (Base       pvp'') = String ("base-" <> prettyPVP pvp'')
   toJSON (UnknownTag x    ) = String (T.pack x)
 
@@ -63,6 +79,7 @@ instance FromJSON Tag where
     "Latest"                             -> pure Latest
     "Recommended"                        -> pure Recommended
     "Prerelease"                         -> pure Prerelease
+    "old"                                -> pure Old
     ('b' : 'a' : 's' : 'e' : '-' : ver') -> case pvp (T.pack ver') of
       Right x -> pure $ Base x
       Left  e -> fail . show $ e
@@ -100,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
@@ -146,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
@@ -209,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

@@ -50,6 +50,7 @@ import           Data.ByteString                ( ByteString )
 import           Data.Either
 import           Data.Foldable
 import           Data.List
+import           Data.List.NonEmpty             ( NonEmpty( (:|) ))
 import           Data.List.Split
 import           Data.Maybe
 import           Data.String.Interpolate
@@ -99,45 +100,52 @@ import qualified Text.Megaparsec               as MP
 
 
 -- | The symlink destination of a ghc tool.
-ghcLinkDestination :: (MonadReader Settings m, MonadThrow m, MonadIO m)
+ghcLinkDestination :: (MonadReader AppState m, MonadThrow m, MonadIO m)
                    => ByteString -- ^ the tool, such as 'ghc', 'haddock' etc.
                    -> GHCTargetVersion
                    -> m ByteString
 ghcLinkDestination tool ver = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState { dirs = Dirs {..} } <- ask
   t <- parseRel tool
   ghcd <- ghcupGHCDir ver
   pure (relativeSymlink binDir (ghcd </> [rel|bin|] </> t))
 
 
 -- | Removes the minor GHC symlinks, e.g. ghc-8.6.5.
-rmMinorSymlinks :: (MonadReader Settings m, MonadIO m, MonadLogger m) => GHCTargetVersion -> m ()
+rmMinorSymlinks :: ( MonadReader AppState m
-rmMinorSymlinks GHCTargetVersion {..} = do
+                   , MonadIO m
-  Settings {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 Settings 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
-  Settings {dirs = Dirs {..}} <- lift ask
+  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}|]
@@ -149,25 +157,25 @@ rmPlain target = do
 
 
 -- | Remove the major GHC symlink, e.g. ghc-8.6.
-rmMajorSymlinks :: (MonadReader Settings 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
-  Settings {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
 
 
@@ -179,26 +187,26 @@ rmMajorSymlinks GHCTargetVersion {..} = do
 
 
 -- | Whethe the given GHC versin is installed.
-ghcInstalled :: (MonadIO m, MonadReader Settings m, MonadThrow m) => GHCTargetVersion -> m Bool
+ghcInstalled :: (MonadIO m, MonadReader AppState m, MonadThrow m) => GHCTargetVersion -> m Bool
 ghcInstalled ver = do
   ghcdir <- ghcupGHCDir ver
   liftIO $ doesDirectoryExist ghcdir
 
 
 -- | Whether the given GHC version is installed from source.
-ghcSrcInstalled :: (MonadIO m, MonadReader Settings m, MonadThrow m) => GHCTargetVersion -> m Bool
+ghcSrcInstalled :: (MonadIO m, MonadReader AppState m, MonadThrow m) => GHCTargetVersion -> m Bool
 ghcSrcInstalled ver = do
   ghcdir <- ghcupGHCDir ver
   liftIO $ doesFileExist (ghcdir </> ghcUpSrcBuiltFile)
 
 
 -- | Whether the given GHC version is set as the current.
-ghcSet :: (MonadReader Settings m, MonadThrow m, MonadIO m)
+ghcSet :: (MonadReader AppState m, MonadThrow m, MonadIO m)
        => Maybe Text   -- ^ the target of the GHC version, if any
                        --  (e.g. armv7-unknown-linux-gnueabihf)
        -> m (Maybe GHCTargetVersion)
 ghcSet mtarget = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState {dirs = Dirs {..}} <- ask
   ghc    <- parseRel $ E.encodeUtf8 (maybe "ghc" (<> "-ghc") mtarget)
   let ghcBin = binDir </> ghc
 
@@ -231,7 +239,7 @@ ghcLinkVersion bs = do
 
 -- | Get all installed GHCs by reading ~/.ghcup/ghc/<dir>.
 -- If a dir cannot be parsed, returns left.
-getInstalledGHCs :: (MonadReader Settings m, MonadIO m) => m [Either (Path Rel) GHCTargetVersion]
+getInstalledGHCs :: (MonadReader AppState m, MonadIO m) => m [Either (Path Rel) GHCTargetVersion]
 getInstalledGHCs = do
   ghcdir <- ghcupGHCBaseDir
   fs     <- liftIO $ hideErrorDef [NoSuchThing] [] $ getDirsFiles' ghcdir
@@ -241,10 +249,10 @@ getInstalledGHCs = do
 
 
 -- | Get all installed cabals, by matching on @~\/.ghcup\/bin/cabal-*@.
-getInstalledCabals :: (MonadReader Settings m, MonadIO m, MonadCatch m)
+getInstalledCabals :: (MonadReader AppState m, MonadIO m, MonadCatch m)
                    => m [Either (Path Rel) Version]
 getInstalledCabals = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState {dirs = Dirs {..}} <- ask
   bins   <- liftIO $ handleIO (\_ -> pure []) $ findFiles
     binDir
     (makeRegexOpts compExtended execBlank ([s|^cabal-.*$|] :: ByteString))
@@ -257,16 +265,16 @@ getInstalledCabals = do
 
 
 -- | Whether the given cabal version is installed.
-cabalInstalled :: (MonadIO m, MonadReader Settings m, MonadCatch m) => Version -> m Bool
+cabalInstalled :: (MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
 cabalInstalled ver = do
   vers <- fmap rights $ getInstalledCabals
   pure $ elem ver $ vers
 
 
 -- Return the currently set cabal version, if any.
-cabalSet :: (MonadReader Settings m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
+cabalSet :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
 cabalSet = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState {dirs = Dirs {..}} <- ask
   let cabalbin = binDir </> [rel|cabal|]
   b        <- handleIO (\_ -> pure False) $ fmap (== SymbolicLink) $ liftIO $ getFileType cabalbin
   if
@@ -303,10 +311,10 @@ cabalSet = do
 
 -- | Get all installed hls, by matching on
 -- @~\/.ghcup\/bin/haskell-language-server-wrapper-<\hlsver\>@.
-getInstalledHLSs :: (MonadReader Settings m, MonadIO m, MonadCatch m)
+getInstalledHLSs :: (MonadReader AppState m, MonadIO m, MonadCatch m)
                  => m [Either (Path Rel) Version]
 getInstalledHLSs = do
-  Settings { dirs = Dirs {..} } <- ask
+  AppState { dirs = Dirs {..} } <- ask
   bins                          <- liftIO $ handleIO (\_ -> pure []) $ findFiles
     binDir
     (makeRegexOpts compExtended
@@ -326,7 +334,7 @@ getInstalledHLSs = do
 
 
 -- | Whether the given HLS version is installed.
-hlsInstalled :: (MonadIO m, MonadReader Settings m, MonadCatch m) => Version -> m Bool
+hlsInstalled :: (MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
 hlsInstalled ver = do
   vers <- fmap rights $ getInstalledHLSs
   pure $ elem ver $ vers
@@ -334,9 +342,9 @@ hlsInstalled ver = do
 
 
 -- Return the currently set hls version, if any.
-hlsSet :: (MonadReader Settings m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
+hlsSet :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
 hlsSet = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState {dirs = Dirs {..}} <- ask
   let hlsBin = binDir </> [rel|haskell-language-server-wrapper|]
 
   liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ do
@@ -357,7 +365,7 @@ hlsSet = do
 
 
 -- | Return the GHC versions the currently selected HLS supports.
-hlsGHCVersions :: ( MonadReader Settings m
+hlsGHCVersions :: ( MonadReader AppState m
                   , MonadIO m
                   , MonadThrow m
                   , MonadCatch m
@@ -383,11 +391,11 @@ hlsGHCVersions = do
 
 
 -- | Get all server binaries for an hls version, if any.
-hlsServerBinaries :: (MonadReader Settings m, MonadIO m)
+hlsServerBinaries :: (MonadReader AppState m, MonadIO m)
                   => Version
                   -> m [Path Rel]
 hlsServerBinaries ver = do
-  Settings { dirs = Dirs {..} } <- ask
+  AppState { dirs = Dirs {..} } <- ask
   liftIO $ handleIO (\_ -> pure []) $ findFiles
     binDir
     (makeRegexOpts
@@ -399,11 +407,11 @@ hlsServerBinaries ver = do
 
 
 -- | Get the wrapper binary for an hls version, if any.
-hlsWrapperBinary :: (MonadReader Settings m, MonadThrow m, MonadIO m)
+hlsWrapperBinary :: (MonadReader AppState m, MonadThrow m, MonadIO m)
                  => Version
                  -> m (Maybe (Path Rel))
 hlsWrapperBinary ver = do
-  Settings { dirs = Dirs {..} } <- ask
+  AppState { dirs = Dirs {..} } <- ask
   wrapper                       <- liftIO $ handleIO (\_ -> pure []) $ findFiles
     binDir
     (makeRegexOpts
@@ -420,7 +428,7 @@ hlsWrapperBinary ver = do
 
 
 -- | Get all binaries for an hls version, if any.
-hlsAllBinaries :: (MonadReader Settings m, MonadIO m, MonadThrow m) => Version -> m [Path Rel]
+hlsAllBinaries :: (MonadReader AppState m, MonadIO m, MonadThrow m) => Version -> m [Path Rel]
 hlsAllBinaries ver = do
   hls     <- hlsServerBinaries ver
   wrapper <- hlsWrapperBinary ver
@@ -428,9 +436,9 @@ hlsAllBinaries ver = do
 
 
 -- | Get the active symlinks for hls.
-hlsSymlinks :: (MonadReader Settings m, MonadIO m, MonadCatch m) => m [Path Rel]
+hlsSymlinks :: (MonadReader AppState m, MonadIO m, MonadCatch m) => m [Path Rel]
 hlsSymlinks = do
-  Settings { dirs = Dirs {..} } <- ask
+  AppState { dirs = Dirs {..} } <- ask
   oldSyms                       <- liftIO $ handleIO (\_ -> pure []) $ findFiles
     binDir
     (makeRegexOpts compExtended
@@ -455,7 +463,7 @@ hlsSymlinks = do
 -- | Extract (major, minor) from any version.
 getMajorMinorV :: MonadThrow m => Version -> m (Int, Int)
 getMajorMinorV Version {..} = case _vChunks of
-  ([Digits x] : [Digits y] : _) -> pure (fromIntegral x, fromIntegral y)
+  ((Digits x :| []) :| ((Digits y :| []):_)) -> pure (fromIntegral x, fromIntegral y)
   _ -> throwM $ ParseError "Could not parse X.Y from version"
 
 
@@ -467,7 +475,7 @@ matchMajor v' major' minor' = case getMajorMinorV v' of
 
 -- | Get the latest installed full GHC version that satisfies X.Y.
 -- This reads `ghcupGHCBaseDir`.
-getGHCForMajor :: (MonadReader Settings m, MonadIO m, MonadThrow m)
+getGHCForMajor :: (MonadReader AppState m, MonadIO m, MonadThrow m)
                => Int        -- ^ major version component
                -> Int        -- ^ minor version component
                -> Maybe Text -- ^ the target triple
@@ -603,16 +611,16 @@ getLatestBaseVersion av pvpVer =
 
 
     -----------------------
-    --[ Settings Getter ]--
+    --[ AppState Getter ]--
     -----------------------
 
 
-getCache :: MonadReader Settings m => m Bool
+getCache :: MonadReader AppState m => m Bool
-getCache = ask <&> cache
+getCache = ask <&> cache . settings
 
 
-getDownloader :: MonadReader Settings m => m Downloader
+getDownloader :: MonadReader AppState m => m Downloader
-getDownloader = ask <&> downloader
+getDownloader = ask <&> downloader . settings
 
 
 
@@ -633,7 +641,7 @@ urlBaseName = parseRel . snd . B.breakEnd (== _slash) . urlDecode False
 -- Returns unversioned relative files, e.g.:
 --
 --   - @["hsc2hs","haddock","hpc","runhaskell","ghc","ghc-pkg","ghci","runghc","hp2ps"]@
-ghcToolFiles :: (MonadReader Settings m, MonadThrow m, MonadFail m, MonadIO m)
+ghcToolFiles :: (MonadReader AppState m, MonadThrow m, MonadFail m, MonadIO m)
              => GHCTargetVersion
              -> Excepts '[NotInstalled] m [Path Rel]
 ghcToolFiles ver = do
@@ -686,7 +694,7 @@ ghcUpSrcBuiltFile = [rel|.ghcup_src_built|]
 
 
 -- | Calls gmake if it exists in PATH, otherwise make.
-make :: (MonadThrow m, MonadIO m, MonadReader Settings m)
+make :: (MonadThrow m, MonadIO m, MonadReader AppState m)
      => [ByteString]
      -> Maybe (Path Abs)
      -> m (Either ProcessError ())
@@ -739,13 +747,13 @@ getChangeLog dls tool (Right tag) =
 --
 --   1. the build directory, depending on the KeepDirs setting
 --   2. the install destination, depending on whether the build failed
-runBuildAction :: (Show (V e), MonadReader Settings m, MonadIO m, MonadMask m)
+runBuildAction :: (Show (V e), MonadReader AppState m, MonadIO m, MonadMask m)
                => Path Abs          -- ^ build directory (cleaned up depending on Settings)
                -> Maybe (Path Abs)  -- ^ dir to *always* clean up on exception
                -> Excepts e m a
                -> Excepts '[BuildFailed] m a
 runBuildAction bdir instdir action = do
-  Settings {..} <- lift ask
+  AppState { settings = Settings {..} } <- lift ask
   let exAction = do
         forM_ instdir $ \dir ->
           liftIO $ hideError doesNotExistErrorType $ deleteDirRecursive dir

lib/GHCup/Utils/Dirs.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE QuasiQuotes           #-}
@@ -14,16 +15,18 @@ Portability : POSIX
 -}
 module GHCup.Utils.Dirs
   ( getDirs
+  , ghcupConfigFile
   , ghcupGHCBaseDir
   , ghcupGHCDir
-  , parseGHCupGHCDir
   , mkGhcupTmpDir
-  , withGHCupTmpDir
+  , parseGHCupGHCDir
   , relativeSymlink
+  , withGHCupTmpDir
   )
 where
 
 
+import           GHCup.Errors
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.MegaParsec
@@ -34,8 +37,11 @@ import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
+import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
 import           Data.Maybe
+import           GHC.IO.Exception               ( IOErrorType(NoSuchThing) )
+import           Haskus.Utils.Variant.Excepts
 import           HPath
 import           HPath.IO
 import           Optics
@@ -49,8 +55,10 @@ import           System.Posix.Env.ByteString    ( getEnv
 import           System.Posix.FilePath   hiding ( (</>) )
 import           System.Posix.Temp.ByteString   ( mkdtemp )
 
+import qualified Data.ByteString.Lazy          as L
 import qualified Data.ByteString.UTF8          as UTF8
 import qualified Data.Text.Encoding            as E
+import qualified Data.Yaml                     as Y
 import qualified System.Posix.FilePath         as FP
 import qualified System.Posix.User             as PU
 import qualified Text.Megaparsec               as MP
@@ -84,6 +92,28 @@ ghcupBaseDir = do
       pure (bdir </> [rel|.ghcup|])
 
 
+-- | ~/.ghcup by default
+--
+-- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
+-- then uses 'XDG_CONFIG_HOME/ghcup' as per xdg spec.
+ghcupConfigDir :: IO (Path Abs)
+ghcupConfigDir = do
+  xdg <- useXDG
+  if xdg
+    then do
+      bdir <- getEnv "XDG_CONFIG_HOME" >>= \case
+        Just r  -> parseAbs r
+        Nothing -> do
+          home <- liftIO getHomeDirectory
+          pure (home </> [rel|.config|])
+      pure (bdir </> [rel|ghcup|])
+    else do
+      bdir <- getEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
+        Just r  -> parseAbs r
+        Nothing -> liftIO getHomeDirectory
+      pure (bdir </> [rel|.ghcup|])
+
+
 -- | If 'GHCUP_USE_XDG_DIRS' is set (to anything),
 -- then uses 'XDG_BIN_HOME' env var or defaults to '~/.local/bin'
 -- (which, sadly is not strictly xdg spec).
@@ -142,27 +172,44 @@ getDirs = do
   binDir   <- ghcupBinDir
   cacheDir <- ghcupCacheDir
   logsDir  <- ghcupLogsDir
+  confDir  <- ghcupConfigDir
   pure Dirs { .. }
 
 
 
+    -------------------
+    --[ GHCup files ]--
+    -------------------
+
+
+ghcupConfigFile :: (MonadIO m)
+                => Excepts '[JSONError] m UserSettings
+ghcupConfigFile = do
+  confDir <- liftIO $ ghcupConfigDir
+  let file = confDir </> [rel|config.yaml|]
+  bs <- liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ fmap Just $ readFile file 
+  case bs of
+      Nothing -> pure defaultUserSettings
+      Just bs' -> lE' JSONDecodeError . bimap show id . Y.decodeEither' . L.toStrict $ bs'
+
+
     -------------------------
     --[ GHCup directories ]--
     -------------------------
 
 
 -- | ~/.ghcup/ghc by default.
-ghcupGHCBaseDir :: (MonadReader Settings m) => m (Path Abs)
+ghcupGHCBaseDir :: (MonadReader AppState m) => m (Path Abs)
 ghcupGHCBaseDir = do
-  Settings {..} <- ask
+  AppState { dirs = Dirs {..} } <- ask
-  pure (baseDir dirs </> [rel|ghc|])
+  pure (baseDir </> [rel|ghc|])
 
 
 -- | Gets '~/.ghcup/ghc/<ghcupGHCDir>'.
 -- The dir may be of the form
 --   * armv7-unknown-linux-gnueabihf-8.8.3
 --   * 8.8.4
-ghcupGHCDir :: (MonadReader Settings m, MonadThrow m)
+ghcupGHCDir :: (MonadReader AppState m, MonadThrow m)
             => GHCTargetVersion
             -> m (Path Abs)
 ghcupGHCDir ver = do

lib/GHCup/Utils/File.hs

@@ -117,7 +117,7 @@ executeOut path args chdir = captureOutStreams $ do
   SPPB.executeFile (toFilePath path) True args Nothing
 
 
-execLogged :: (MonadReader Settings m, MonadIO m, MonadThrow m)
+execLogged :: (MonadReader AppState m, MonadIO m, MonadThrow m)
            => ByteString       -- ^ thing to execute
            -> Bool             -- ^ whether to search PATH for the thing
            -> [ByteString]     -- ^ args for the thing
@@ -126,7 +126,7 @@ execLogged :: (MonadReader Settings m, MonadIO m, MonadThrow m)
            -> Maybe [(ByteString, ByteString)] -- ^ optional environment
            -> m (Either ProcessError ())
 execLogged exe spath args lfile chdir env = do
-  Settings {dirs = Dirs {..}, ..} <- ask
+  AppState { settings = Settings {..}, dirs = Dirs {..} } <- ask
   logfile       <- (logsDir </>) <$> parseRel (toFilePath lfile <> ".log")
   liftIO $ bracket (createFile (toFilePath logfile) newFilePerms)
                    closeFd
@@ -440,13 +440,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/Logger.hs

@@ -65,9 +65,9 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
     rawOutter outr
 
 
-initGHCupFileLogging :: (MonadIO m, MonadReader Settings m) => Path Rel -> m (Path Abs)
+initGHCupFileLogging :: (MonadIO m, MonadReader AppState m) => Path Rel -> m (Path Abs)
 initGHCupFileLogging context = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState {dirs = Dirs {..}} <- ask
   let logfile = logsDir </> context
   liftIO $ do
     createDirRecursive' logsDir

lib/GHCup/Utils/MegaParsec.hs

@@ -25,6 +25,7 @@ import           Data.Text                      ( Text )
 import           Data.Versions
 import           Data.Void
 
+import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T
 import qualified Text.Megaparsec               as MP
 
@@ -73,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
@@ -90,7 +91,22 @@ ghcTargetVerP =
                   (Digits _) -> True
                   (Str    _) -> False
                 )
+            . fmap NE.toList
+            . NE.toList
             $ (_vChunks v)
     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/Utils/Version/QQ.hs

@@ -42,6 +42,8 @@ deriving instance Data SemVer
 deriving instance Lift SemVer
 deriving instance Data Mess
 deriving instance Lift Mess
+deriving instance Data MChunk
+deriving instance Lift MChunk
 deriving instance Data PVP
 deriving instance Lift PVP
 deriving instance Lift VSep

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,12 +23,25 @@ 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
-ghcUpVer = [pver|0.1.11|]
+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
+

stack.yaml

@@ -0,0 +1,72 @@
+resolver: lts-16.17
+
+packages:
+  - .
+
+extra-deps:
+  - 3rdparty/lzma
+  - 3rdparty/lzma-clib
+  - 3rdparty/zlib
+
+  - git: https://github.com/haskus/packages.git
+    commit: 80a1c5fc07f7226c424250ec17f674cd4d618f42
+    subdirs:
+      - haskus-utils-types
+
+  - git: https://github.com/hasufell/hpath.git
+    commit: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
+    subdirs:
+      - hpath-io
+      - hpath-directory
+
+  - git: https://github.com/hasufell/text-conversions.git
+    commit: 9abf0e5e5664a3178367597c32db19880477a53c
+
+  - IfElse-0.85@sha256:6939b94acc6a55f545f63a168a349dd2fbe4b9a7cca73bf60282db5cc6aa47d2,445
+  - QuickCheck-2.14.1@sha256:01e46d7b0a8d3148288ec977625f62d5516ebb5031a50c63f0453863301b4a79,7736
+  - ascii-string-1.0.1.4@sha256:fa34f1d9ba57e8e89c0d4c9cef5e01ba32cb2d4373d13f92dcc0b531a6c6749b,2582
+  - base64-bytestring-1.1.0.0@sha256:190264fef9e65d9085f00ccda419137096d1dc94777c58272bc96821dc7f37c3,2334
+  - brick-0.55@sha256:f98736eca0cd694837062e06da4655eed969d53b789dfd919716e9b6f5b4c5ce,15858
+  - brotli-0.0.0.0@sha256:2bf383a4cd308745740986be0b18381c5a0784393fe69b91456aacb2d603de46,2964
+  - brotli-streams-0.0.0.0@sha256:1af1e22f67b8bfd6ad0d05e61825e7a178d738f689ebbb21c1aab5f1bbcae176,2331
+  - chs-cabal-0.1.1.0@sha256:20ec6a9fb5ab6991f1a4adf157c537bd5d3b98d08d3c09c387c954c7c50bd011,1153
+  - chs-deps-0.1.0.0@sha256:0cdada6d2c682c41b20331b8c63c2ecfc7e806928585195fd544c9d41f3074fd,2496
+  - composition-prelude-3.0.0.0@sha256:7407835ce8c1e0e2fd6febd25391b12989b216773e685e3cf95bd89072af0ecc,1149
+  - haskus-utils-data-1.3@sha256:f62c4e49021b463185d043f7b69c727b63af641a71d7edd582d9f4f98e80e500,1466
+  - haskus-utils-variant-3.0@sha256:8d51e45d3b664e61ccc25a58b37c0ccc4ee7537138b9fee21cd15c356906dd34,2159
+  - hpath-0.11.0@sha256:12b8405bee13d0007d644a888ef8407069ce7bbbd76970f8746b801447124ade,1440
+  - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
+  - hpath-posix-0.13.2@sha256:eec4ff2b00dc86be847aca0f409fc8f6212ffd2170ec36a17dc9a52b46562392,1615
+  - http-io-streams-0.1.4.0@sha256:9a74a059daeddf7a41d361919190b9f4d4292f05e0e4bdf156e2098a116a8145,3582
+  - libarchive-3.0.0.0@sha256:e4157b307acf16cca0ec3d398ac5093cc06f092b33a9743be559ef0f6c6ae52f,11204
+  - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
+  - primitive-extras-0.8@sha256:fca0310150496867f5b9421fe1541ecda87fae17eae44885a29f9c52dd00c8ff,2963
+  - primitive-unlifted-0.1.3.0@sha256:a98f827740f5dcf097d885b3a47c32f4462204449620abc9d51b8c4f8619f9e6,1427
+  - random-1.2.0@sha256:4321209c8faedc034810ea8ed0dbc4a36f1a1df97b75af024219f2f533da57de,6094
+  - splitmix-0.1.0.1@sha256:22f9662e7e8b173421872241edd39350078a9ed4bb9e9f503948c5b483c79276,5253
+  - streamly-posix-0.1.0.1@sha256:5d89b806281035d34020387ed99dde1ddab282c7ed66df3b7cd010b38fd3517b,2138
+  - strict-base-0.4.0.0@sha256:2ff4e43cb95eedf2995558d7fc34d19362846413dd39e6aa6a5b3ea8228fef9f,1248
+  - tar-bytestring-0.6.3.2@sha256:88f29bed56b688c543a4cb3986402d64b360f76b3fd9b88ac618b8344f8da712,5715
+  - versions-4.0.1@sha256:0f644c1587d38f0eb3c3fe364bf1822424db43cbd4d618d0e21473b062c45239,1936
+  - vty-5.30@sha256:4af3938d7b9e6096e222bf52d0ea5d39873bc6fe19febd34106906306af13730,20857
+  - xor-0.0.1.0@sha256:f8362b4a68562b9afbcd727ff64c1a303970df3a032e0033d2f4c094c3501df3,2243
+
+flags:
+  http-io-streams:
+    brotli: false
+
+  libarchive:
+    system-libarchive: false
+
+  ghcup:
+    tui: true
+    internal-downloader: true
+
+system-ghc: true
+compiler: ghc-8.8.4
+compiler-check: match-exact
+
+ghc-options:
+  "$locals": -O2
+  streamly: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+  ghcup: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16

test/GHCup/ArbitraryTypes.hs

@@ -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)