Update travis

Merge remote-tracking branch 'origin/merge-requests/10'
Use BOOTSTAP_HASKELL_{GHC,CABAL}_VERSION env vars as overrides
2020-06-14 12:36:13 +02:00 · 2020-06-14 11:50:02 +02:00 · 2020-06-14 00:15:50 +02:00 · 2020-05-30 22:15:48 +02:00 · 2020-05-17 18:43:58 +02:00 · 2020-05-15 21:53:45 +02:00
12 changed files with 627 additions and 232 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -97,13 +97,13 @@ variables:
 test:linux:recommended:
  extends: .test_ghcup_version:linux
  variables:
-    GHC_VERSION: "8.6.5"
+    GHC_VERSION: "8.8.3"
    CABAL_VERSION: "3.2.0.0"

 test:linux:latest:
  extends: .test_ghcup_version:linux
  variables:
-    GHC_VERSION: "8.8.3"
+    GHC_VERSION: "8.10.1"
    CABAL_VERSION: "3.2.0.0"
  allow_failure: true

@@ -113,13 +113,13 @@ test:linux:latest:
 test:mac:recommended:
  extends: .test_ghcup_version:darwin
  variables:
-    GHC_VERSION: "8.6.5"
+    GHC_VERSION: "8.8.3"
    CABAL_VERSION: "3.2.0.0"

 test:mac:latest:
  extends: .test_ghcup_version:darwin
  variables:
-    GHC_VERSION: "8.8.3"
+    GHC_VERSION: "8.10.1"
    CABAL_VERSION: "3.2.0.0"
  allow_failure: true

@@ -129,13 +129,13 @@ test:mac:latest:
 test:freebsd:recommended:
  extends: .test_ghcup_version:freebsd
  variables:
-    GHC_VERSION: "8.6.5"
+    GHC_VERSION: "8.8.3"
    CABAL_VERSION: "3.2.0.0"

 test:freebsd:latest:
  extends: .test_ghcup_version:freebsd
  variables:
-    GHC_VERSION: "8.8.3"
+    GHC_VERSION: "8.10.1"
    CABAL_VERSION: "3.2.0.0"
  allow_failure: true

@@ -193,5 +193,5 @@ release:freebsd:
    - ./.gitlab/before_script/freebsd/install_deps.sh
  variables:
    ARTIFACT: "x86_64-portbld-freebsd-ghcup"
-    GHC_VERSION: "8.6.5"
+    GHC_VERSION: "8.8.3"

--- a/.gitlab/before_script/freebsd/install_deps.sh
+++ b/.gitlab/before_script/freebsd/install_deps.sh
@@ -11,15 +11,8 @@ mkdir -p "${TMPDIR}"
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-portbld-freebsd-ghcup > ./ghcup-bin
 chmod +x ghcup-bin

-mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
-# ./ghcup-bin install ${GHC_VERSION}
-# ./ghcup-bin install-cabal ${CABAL_VERSION}
-# ./ghcup-bin set ${GHC_VERSION}
-
-# install cabal-3.2.0.0
-curl -sSfL -o cabal-install-3.2.0.0-x86_64-portbld-freebsd.tar.xz 'https://hasufell.de/d/d3e215db133e4fcaa61e/files/?p=/cabal-install-3.2.0.0-x86_64-portbld-freebsd.tar.xz&dl=1'
-tar xf cabal-install-3.2.0.0-x86_64-portbld-freebsd.tar.xz
-cp cabal "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin/cabal"
-chmod +x "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin/cabal"
+./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}

 exit 0
--- a/.gitlab/script/ghcup_release.sh
+++ b/.gitlab/script/ghcup_release.sh
@@ -26,5 +26,6 @@ fi
 mkdir out
 cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" .
 ver=$(./ghcup --numeric-version)
+strip -s ./ghcup
 cp ghcup out/${ARTIFACT}-${ver}

--- a/.travis/build.sh
+++ b/.travis/build.sh
@@ -1,4 +1,4 @@
-#/bin/sh
+#!/bin/sh

 set -ex

@@ -19,4 +19,6 @@ ghcup set 8.8.3

 cabal update
 cabal build --constraint="zlib static" --constraint="lzma static"
-cp "$(cabal new-exec --verbose=0 --offline sh -- -c 'command -v ghcup')" "./${ARTIFACT}"
+cp "$(cabal new-exec --verbose=0 --offline sh -- -c 'command -v ghcup')" .
+strip -s ghcup
+cp ghcup "./${ARTIFACT}"
--- a/README.md
+++ b/README.md
@@ -47,16 +47,16 @@ Common use cases are:
 ghcup list

 # install the recommended GHC version
-ghcup install
+ghcup install ghc

 # install a specific GHC version
-ghcup install 8.2.2
+ghcup install ghc 8.2.2

 # set the currently "active" GHC version
-ghcup set 8.4.4
+ghcup set ghc 8.4.4

 # install cabal-install
-ghcup install-cabal
+ghcup install cabal

 # update ghcup itself
 ghcup upgrade
--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
@@ -23,6 +23,7 @@ import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
 import           GHCup.Version

+import           Control.Exception.Safe
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
 #endif
@@ -53,7 +54,7 @@ import           System.Console.Pretty
 import           System.Environment
 import           System.Exit
 import           System.IO               hiding ( appendFile )
-import           Text.Read
+import           Text.Read               hiding ( lift )
 import           Text.Layout.Table
 import           URI.ByteString

@@ -82,11 +83,11 @@ data Options = Options
  }

 data Command
-  = Install InstallOptions
-  | InstallCabal InstallOptions
-  | SetGHC SetGHCOptions
+  = Install (Either InstallCommand InstallOptions)
+  | InstallCabalLegacy InstallOptions
+  | Set (Either SetCommand SetOptions)
  | List ListOptions
-  | Rm RmOptions
+  | Rm (Either RmCommand RmOptions)
  | DInfo
  | Compile CompileCommand
  | Upgrade UpgradeOpts Bool
@@ -101,13 +102,19 @@ prettyToolVer (ToolVersion v') = T.unpack $ prettyTVer v'
 prettyToolVer (ToolTag t) = show t


+data InstallCommand = InstallGHC InstallOptions
+                    | InstallCabal InstallOptions
+
 data InstallOptions = InstallOptions
  { instVer      :: Maybe ToolVersion
  , instPlatform :: Maybe PlatformRequest
  }

-data SetGHCOptions = SetGHCOptions
-  { ghcVer :: Maybe ToolVersion
+data SetCommand = SetGHC SetOptions
+                | SetCabal SetOptions
+
+data SetOptions = SetOptions
+  { sToolVer :: Maybe ToolVersion
  }

 data ListOptions = ListOptions
@@ -116,6 +123,9 @@ data ListOptions = ListOptions
  , lRawFormat :: Bool
  }

+data RmCommand = RmGHC RmOptions
+               | RmCabal Version
+
 data RmOptions = RmOptions
  { ghcVer :: GHCTargetVersion
  }
@@ -213,44 +223,38 @@ com =
  subparser
      (  command
          "install"
-          ((info
-             ((Install <$> installOpts) <**> helper)
-             (  progDesc "Install or update GHC"
-             <> footerDoc (Just $ text installFooter)
-             )
-           )
+          (   Install
+          <$> (info
+                (installParser <**> helper)
+                (  progDesc "Install or update GHC/cabal"
+                <> footerDoc (Just $ text installToolFooter)
+                )
+              )
          )
      <> command
           "set"
-           (   SetGHC
-           <$> (info
-                 (setGHCOpts <**> helper)
-                 (  progDesc "Set currently active GHC version"
-                 <> footerDoc (Just $ text setFooter)
-                 )
-               )
-           )
-      <> command
-           "rm"
-           (   Rm
-           <$> (info (rmOpts <**> helper) (progDesc "Remove a GHC version"))
-           )
-
-      <> command
-           "install-cabal"
           ((info
-              ((InstallCabal <$> installOpts) <**> helper)
-              (  progDesc "Install or update cabal"
-              <> footerDoc (Just $ text installCabalFooter)
+              (Set <$> setParser <**> helper)
+              (  progDesc "Set currently active GHC/cabal version"
+              <> footerDoc (Just $ text setFooter)
              )
            )
           )
+      <> command
+           "rm"
+           ((info
+              (Rm <$> rmParser <**> helper)
+              (  progDesc "Remove a GHC/cabal version"
+              <> footerDoc (Just $ text rmFooter)
+              )
+            )
+           )
+
      <> command
           "list"
-           (   List
-           <$> (info (listOpts <**> helper)
-                     (progDesc "Show available GHCs and other tools")
-               )
+           ((info (List <$> listOpts <**> helper)
+                  (progDesc "Show available GHCs and other tools")
+            )
           )
      <> command
           "upgrade"
@@ -284,33 +288,95 @@ com =
               )
          <> command
               "changelog"
-               ((info (fmap ChangeLog changelogP <**> helper)
-                      (progDesc "Find/show changelog"
-                      <> footerDoc (Just $ text changeLogFooter)
-                      )
+               ((info
+                  (fmap ChangeLog changelogP <**> helper)
+                  (  progDesc "Find/show changelog"
+                  <> footerDoc (Just $ text changeLogFooter)
+                  )
                )
               )
          <> commandGroup "Other commands:"
          <> hidden
          )
+    <|> subparser
+          (  command
+              "install-cabal"
+              ((info
+                 ((InstallCabalLegacy <$> installOpts) <**> helper)
+                 (  progDesc "Install or update cabal"
+                 <> footerDoc (Just $ text installCabalFooter)
+                 )
+               )
+              )
+          <> internal
+          )
 where
-  installFooter = [i|Discussion:
-  Installs the specified GHC version (or a recommended default one) into
-  a self-contained "~/.ghcup/ghc/<ghcver>" directory
-  and symlinks the ghc binaries to "~/.ghcup/bin/<binary>-<ghcver>".|]
+  installToolFooter :: String
+  installToolFooter = [i|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').|]
+
+  setFooter :: String
  setFooter = [i|Discussion:
-  Sets the the current GHC version by creating non-versioned
-  symlinks for all ghc binaries of the specified version in
-  "~/.ghcup/bin/<binary>".|]
-  installCabalFooter = [i|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').|]
+
+  rmFooter :: String
+  rmFooter = [i|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').|]
+
+  changeLogFooter :: String
+  changeLogFooter = [i|Discussion:
+  By default returns the URI of the ChangeLog of the latest GHC release.
+  Pass '-o' to automatically open via xdg-open.|]
+
+
+installCabalFooter :: String
+installCabalFooter = [i|Discussion:
  Installs the specified cabal-install version (or a recommended default one)
  into "~/.ghcup/bin", so it can be overwritten by later
  "cabal install cabal-install", which installs into "~/.cabal/bin" by
  default. Make sure to set up your PATH appropriately, so the cabal
  installation takes precedence.|]
-  changeLogFooter = [i|Discussion:
-  By default returns the URI of the ChangeLog of the latest GHC release.
-  Pass '-o' to automatically open via xdg-open.|]
+
+
+installParser :: Parser (Either InstallCommand InstallOptions)
+installParser =
+  (Left <$> subparser
+      (  command
+          "ghc"
+          (   InstallGHC
+          <$> (info
+                (installOpts <**> helper)
+                (  progDesc "Install GHC"
+                <> footerDoc (Just $ text installGHCFooter)
+                )
+              )
+          )
+      <> command
+           "cabal"
+           (   InstallCabal
+           <$> (info
+                 (installOpts <**> helper)
+                 (  progDesc "Install Cabal"
+                 <> footerDoc (Just $ text installCabalFooter)
+                 )
+               )
+           )
+      )
+    )
+    <|> (Right <$> installOpts)
+ where
+  installGHCFooter :: String
+  installGHCFooter = [i|Discussion:
+  Installs the specified GHC version (or a recommended default one) into
+  a self-contained "~/.ghcup/ghc/<ghcver>" directory
+  and symlinks the ghc binaries to "~/.ghcup/bin/<binary>-<ghcver>".|]


 installOpts :: Parser InstallOptions
@@ -330,8 +396,46 @@ installOpts =
    <*> optional toolVersionArgument


-setGHCOpts :: Parser SetGHCOptions
-setGHCOpts = SetGHCOptions <$> optional toolVersionArgument
+setParser :: Parser (Either SetCommand SetOptions)
+setParser =
+  (Left <$> subparser
+      (  command
+          "ghc"
+          (   SetGHC
+          <$> (info
+                (setOpts <**> helper)
+                (  progDesc "Set GHC version"
+                <> footerDoc (Just $ text setGHCFooter)
+                )
+              )
+          )
+      <> command
+           "cabal"
+           (   SetCabal
+           <$> (info
+                 (setOpts <**> helper)
+                 (  progDesc "Set Cabal version"
+                 <> footerDoc (Just $ text setCabalFooter)
+                 )
+               )
+           )
+      )
+    )
+    <|> (Right <$> setOpts)
+ where
+  setGHCFooter :: String
+  setGHCFooter = [i|Discussion:
+    Sets the the current GHC version by creating non-versioned
+    symlinks for all ghc binaries of the specified version in
+    "~/.ghcup/bin/<binary>".|]
+
+  setCabalFooter :: String
+  setCabalFooter = [i|Discussion:
+    Sets the the current Cabal version.|]
+
+
+setOpts :: Parser SetOptions
+setOpts = SetOptions <$> optional toolVersionArgument

 listOpts :: Parser ListOptions
 listOpts =
@@ -357,6 +461,26 @@ listOpts =
          (short 'r' <> long "raw-format" <> help "More machine-parsable format"
          )

+
+rmParser :: Parser (Either RmCommand RmOptions)
+rmParser =
+  (Left <$> subparser
+      (  command
+          "ghc"
+          (RmGHC <$> (info (rmOpts <**> helper) (progDesc "Remove GHC version")))
+      <> command
+           "cabal"
+           (   RmCabal
+           <$> (info (versionParser' <**> helper)
+                     (progDesc "Remove Cabal version")
+               )
+           )
+      )
+    )
+    <|> (Right <$> rmOpts)
+
+
+
 rmOpts :: Parser RmOptions
 rmOpts = RmOptions <$> versionArgument

@@ -534,6 +658,12 @@ versionParser = option
  (short 'v' <> long "version" <> metavar "VERSION" <> help "The target version"
  )

+versionParser' :: Parser Version
+versionParser' = argument
+  (eitherReader (bimap show id . version . T.pack))
+  (metavar "VERSION")
+
+
 tagEither :: String -> Either String Tag
 tagEither s' = case fmap toLower s' of
  "recommended" -> Right Recommended
@@ -744,7 +874,11 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                , rawOutter    = appendFile logfile
                }

-          -- wrapper to run effects with settings
+
+          -------------------------
+          -- Effect interpreters --
+          -------------------------
+
          let runInstTool =
                runLogger
                  . flip runReaderT settings
@@ -776,7 +910,15 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                    , TagNotFound
                    ]

-          let runListGHC = runE @'[] . runLogger
+          let
+            runSetCabal =
+              runLogger
+                . runE
+                  @'[ NotInstalled
+                    , TagNotFound
+                    ]
+
+          let runListGHC = runLogger . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound]

          let runRmGHC =
                runLogger . flip runReaderT settings . runE @'[NotInstalled]
@@ -811,13 +953,16 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                  . flip runReaderT settings
                  . runResourceT
                  . runE
-                    @'[ BuildFailed
+                    @'[ AlreadyInstalled
+                      , BuildFailed
+                      , CopyError
                      , DigestError
                      , DistroNotFound
                      , DownloadFailed
                      , NoCompatibleArch
                      , NoCompatiblePlatform
                      , NoDownload
+                      , NotInstalled
                      , PatchFailed
                      , UnknownArchive
                      ]
@@ -838,6 +983,11 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      , DownloadFailed
                      ]

+
+          ---------------------------
+          -- Getting download info --
+          ---------------------------
+
          (GHCupInfo treq dls) <-
            ( runLogger
              . flip runReaderT settings
@@ -851,81 +1001,143 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      runLogger
                        ($(logError) [i|Error fetching download info: #{e}|])
                      exitWith (ExitFailure 2)
-          runLogger $ checkForUpdates dls
+          (runLogger
+              . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound] $ checkForUpdates dls
+              )
+              >>= \case
+                    VRight _ -> pure ()
+                    VLeft  e -> do
+                      runLogger
+                        ($(logError) [i|Error checking for upgrades: #{e}|])
+
+
+          -----------------------
+          -- Command functions --
+          -----------------------
+
+          let installGHC InstallOptions{..} =
+                  (runInstTool $ do
+                      v <- liftE $ fromVersion dls instVer GHC
+                      liftE $ installGHCBin dls (_tvVersion v) instPlatform -- FIXME: ugly sharing of tool version
+                    )
+                    >>= \case
+                          VRight _ -> do
+                            runLogger $ $(logInfo) ("GHC installation successful")
+                            pure ExitSuccess
+                          VLeft (V (AlreadyInstalled _ v)) -> do
+                            runLogger $ $(logWarn)
+                              [i|GHC ver #{prettyVer v} already installed|]
+                            pure ExitSuccess
+                          VLeft (V (BuildFailed tmpdir e)) -> do
+                            case keepDirs of
+                              Never -> runLogger ($(logError) [i|Build failed with #{e}|])
+                              _ -> runLogger ($(logError) [i|Build failed with #{e}
+    Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues.
+    Make sure to clean up #{tmpdir} afterwards.|])
+                            pure $ ExitFailure 3
+                          VLeft (V NoDownload) -> do
+
+                            runLogger $ do
+                              case instVer of
+                                Just iver -> $(logError) [i|No available GHC version for #{prettyToolVer iver}|]
+                                Nothing -> $(logError) [i|No available recommended GHC version|]
+                            pure $ ExitFailure 3
+                          VLeft e -> do
+                            runLogger $ do
+                              $(logError) [i|#{e}|]
+                              $(logError) [i|Also check the logs in ~/.ghcup/logs|]
+                            pure $ ExitFailure 3
+
+
+          let installCabal InstallOptions{..} =
+                (runInstTool $ do
+                    v <- liftE $ fromVersion dls instVer Cabal
+                    liftE $ installCabalBin dls (_tvVersion v) instPlatform -- FIXME: ugly sharing of tool version
+                  )
+                  >>= \case
+                        VRight _ -> do
+                          runLogger $ $(logInfo) ("Cabal installation successful")
+                          pure ExitSuccess
+                        VLeft (V (AlreadyInstalled _ v)) -> do
+                          runLogger $ $(logWarn)
+                            [i|Cabal ver #{prettyVer v} already installed|]
+                          pure ExitSuccess
+                        VLeft (V NoDownload) -> do
+
+                          runLogger $ do
+                            case instVer of
+                              Just iver -> $(logError) [i|No available Cabal version for #{prettyToolVer iver}|]
+                              Nothing -> $(logError) [i|No available recommended Cabal version|]
+                          pure $ ExitFailure 4
+                        VLeft e -> do
+                          runLogger $ do
+                            $(logError) [i|#{e}|]
+                            $(logError) [i|Also check the logs in ~/.ghcup/logs|]
+                          pure $ ExitFailure 4
+
+          let setGHC' SetOptions{..} =
+                (runSetGHC $ do
+                    v <- liftE $ fromVersion dls sToolVer GHC
+                    liftE $ setGHC v SetGHCOnly
+                  )
+                  >>= \case
+                        VRight (GHCTargetVersion{..}) -> do
+                          runLogger
+                            $ $(logInfo)
+                                [i|GHC #{prettyVer _tvVersion} successfully set as default version#{maybe "" (" for cross target " <>) _tvTarget}|]
+                          pure ExitSuccess
+                        VLeft e -> do
+                          runLogger ($(logError) [i|#{e}|])
+                          pure $ ExitFailure 5
+
+          let setCabal' SetOptions{..} =
+                (runSetCabal $ do
+                    v <- liftE $ fromVersion dls sToolVer Cabal
+                    liftE $ setCabal (_tvVersion v)
+                  )
+                  >>= \case
+                        VRight _ -> pure ExitSuccess
+                        VLeft  e -> do
+                          runLogger ($(logError) [i|#{e}|])
+                          pure $ ExitFailure 14
+
+          let rmGHC' RmOptions{..} =
+                (runRmGHC $ do
+                    liftE $ rmGHCVer ghcVer
+                  )
+                  >>= \case
+                        VRight _ -> pure ExitSuccess
+                        VLeft  e -> do
+                          runLogger ($(logError) [i|#{e}|])
+                          pure $ ExitFailure 7
+
+          let rmCabal' tv =
+                (runSetCabal $ do
+                    liftE $ rmCabalVer tv
+                  )
+                  >>= \case
+                        VRight _ -> pure ExitSuccess
+                        VLeft  e -> do
+                          runLogger ($(logError) [i|#{e}|])
+                          pure $ ExitFailure 15
+
+

          res <- case optCommand of
-            Install (InstallOptions {..}) ->
-              (runInstTool $ do
-                  v <- liftE $ fromVersion dls instVer GHC
-                  liftE $ installGHCBin dls (_tvVersion v) instPlatform -- FIXME: ugly sharing of tool version
-                )
-                >>= \case
-                      VRight _ -> do
-                        runLogger $ $(logInfo) ("GHC installation successful")
-                        pure ExitSuccess
-                      VLeft (V (AlreadyInstalled _ v)) -> do
-                        runLogger $ $(logWarn)
-                          [i|GHC ver #{prettyVer v} already installed|]
-                        pure ExitSuccess
-                      VLeft (V (BuildFailed tmpdir e)) -> do
-                        case keepDirs of
-                          Never -> runLogger ($(logError) [i|Build failed with #{e}|])
-                          _ -> runLogger ($(logError) [i|Build failed with #{e}
-Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues.
-Make sure to clean up #{tmpdir} afterwards.|])
-                        pure $ ExitFailure 3
-                      VLeft (V NoDownload) -> do
+            Install (Right iopts) -> do
+              runLogger ($(logWarn) [i|This is an old-style command for installing GHC. Use 'ghcup install ghc' instead.|])
+              installGHC iopts
+            Install (Left (InstallGHC iopts)) -> installGHC iopts
+            Install (Left (InstallCabal iopts)) -> installCabal iopts
+            InstallCabalLegacy iopts -> do
+              runLogger ($(logWarn) [i|This is an old-style command for installing cabal. Use 'ghcup install cabal' instead.|])
+              installCabal iopts

-                        runLogger $ do
-                          case instVer of
-                            Just iver -> $(logError) [i|No available GHC version for #{prettyToolVer iver}|]
-                            Nothing -> $(logError) [i|No available recommended GHC version|]
-                        pure $ ExitFailure 3
-                      VLeft e -> do
-                        runLogger $ do
-                          $(logError) [i|#{e}|]
-                          $(logError) [i|Also check the logs in ~/.ghcup/logs|]
-                        pure $ ExitFailure 3
-            InstallCabal (InstallOptions {..}) ->
-              (runInstTool $ do
-                  v <- liftE $ fromVersion dls instVer Cabal
-                  liftE $ installCabalBin dls (_tvVersion v) instPlatform -- FIXME: ugly sharing of tool version
-                )
-                >>= \case
-                      VRight _ -> do
-                        runLogger $ $(logInfo) ("Cabal installation successful")
-                        pure ExitSuccess
-                      VLeft (V (AlreadyInstalled _ v)) -> do
-                        runLogger $ $(logWarn)
-                          [i|Cabal ver #{prettyVer v} already installed|]
-                        pure ExitSuccess
-                      VLeft (V NoDownload) -> do
-
-                        runLogger $ do
-                          case instVer of
-                            Just iver -> $(logError) [i|No available Cabal version for #{prettyToolVer iver}|]
-                            Nothing -> $(logError) [i|No available recommended Cabal version|]
-                        pure $ ExitFailure 4
-                      VLeft e -> do
-                        runLogger $ do
-                          $(logError) [i|#{e}|]
-                          $(logError) [i|Also check the logs in ~/.ghcup/logs|]
-                        pure $ ExitFailure 4
-
-            SetGHC (SetGHCOptions {..}) ->
-              (runSetGHC $ do
-                  v <- liftE $ fromVersion dls ghcVer GHC
-                  liftE $ setGHC v SetGHCOnly
-                )
-                >>= \case
-                      VRight (GHCTargetVersion{..}) -> do
-                        runLogger
-                          $ $(logInfo)
-                              [i|GHC #{prettyVer _tvVersion} successfully set as default version#{maybe "" (" for cross target " <>) _tvTarget}|]
-                        pure ExitSuccess
-                      VLeft e -> do
-                        runLogger ($(logError) [i|#{e}|])
-                        pure $ ExitFailure 5
+            Set (Right sopts) -> do
+              runLogger ($(logWarn) [i|This is an old-style command for setting GHC. Use 'ghcup set ghc' instead.|])
+              setGHC' sopts
+            Set (Left (SetGHC sopts)) -> setGHC' sopts
+            Set (Left (SetCabal sopts)) -> setCabal' sopts

            List (ListOptions {..}) ->
              (runListGHC $ do
@@ -940,15 +1152,11 @@ Make sure to clean up #{tmpdir} afterwards.|])
                        runLogger ($(logError) [i|#{e}|])
                        pure $ ExitFailure 6

-            Rm (RmOptions {..}) ->
-              (runRmGHC $ do
-                  liftE $ rmGHCVer ghcVer
-                )
-                >>= \case
-                      VRight _ -> pure ExitSuccess
-                      VLeft  e -> do
-                        runLogger ($(logError) [i|#{e}|])
-                        pure $ ExitFailure 7
+            Rm (Right rmopts) -> do
+              runLogger ($(logWarn) [i|This is an old-style command for removing GHC. Use 'ghcup rm ghc' instead.|])
+              rmGHC' rmopts
+            Rm (Left (RmGHC rmopts)) -> rmGHC' rmopts
+            Rm (Left (RmCabal rmopts)) -> rmCabal' rmopts

            DInfo ->
              do
@@ -1153,7 +1361,8 @@ printListResult raw lr = do
                       , intercalate "," $ (fmap printTag $ sort lTag)
                       , intercalate ","
                       $  (if fromSrc then [color' Blue "compiled"] else mempty)
-                       ++ (if lStray then [color' Blue "stray"] else mempty)
+                       ++ (if lStray then [color' Yellow "stray"] else mempty)
+                       ++ (if lNoBindist then [color' Red "no-bindist"] else mempty)
                       ]
            )
            lr
@@ -1167,29 +1376,35 @@ printListResult raw lr = do
    True  -> flip const
    False -> color

-checkForUpdates :: (MonadThrow m, MonadIO m, MonadFail m, MonadLogger m)
+checkForUpdates :: (MonadCatch m, MonadLogger m, MonadThrow m, MonadIO m, MonadFail m, MonadLogger m)
                => GHCupDownloads
-                -> m ()
+                -> Excepts
+                     '[ NoCompatiblePlatform
+                      , NoCompatibleArch
+                      , DistroNotFound
+                      ]
+                     m
+                     ()
 checkForUpdates dls = do
  forM_ (getLatest dls GHCup) $ \l -> do
    (Right ghc_ver) <- pure $ version $ prettyPVP ghcUpVer
    when (l > ghc_ver)
-      $ $(logWarn)
+      $ lift $ $(logWarn)
          [i|New GHCup version available: #{prettyVer l}. To upgrade, run 'ghcup upgrade'|]

  forM_ (getLatest dls GHC) $ \l -> do
    mghc_ver <- latestInstalled GHC
    forM mghc_ver $ \ghc_ver ->
      when (l > ghc_ver)
-        $ $(logWarn)
-            [i|New GHC version available: #{prettyVer l}. To upgrade, run 'ghcup install #{prettyVer l}'|]
+        $ lift $ $(logWarn)
+            [i|New GHC version available: #{prettyVer l}. To upgrade, run 'ghcup install ghc #{prettyVer l}'|]

  forM_ (getLatest dls Cabal) $ \l -> do
    mcabal_ver <- latestInstalled Cabal
    forM mcabal_ver $ \cabal_ver ->
      when (l > cabal_ver)
-        $ $(logWarn)
-            [i|New Cabal version available: #{prettyVer l}. To upgrade, run 'ghcup install-cabal #{prettyVer l}'|]
+        $ lift $ $(logWarn)
+            [i|New Cabal version available: #{prettyVer l}. To upgrade, run 'ghcup install cabal #{prettyVer l}'|]

 where
  latestInstalled tool = (fmap lVer . lastMay)
--- a/8
+++ b/8
@@ -4,6 +4,8 @@
 (

 : "${GHCUP_INSTALL_BASE_PREFIX:=$HOME}"
+: "${BOOTSTRAP_HASKELL_GHC_VERSION:=recommended}"
+: "${BOOTSTRAP_HASKELL_CABAL_VERSION:=recommended}"

 die() {
    (>&2 printf "\\033[0;31m%s\\033[0m\\n" "$1")
@@ -127,10 +129,10 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
    read -r answer </dev/tty
 fi

-eghcup --cache install
+eghcup --cache install "${BOOTSTRAP_HASKELL_GHC_VERSION}"

-eghcup set
-eghcup --cache install-cabal
+eghcup set "${BOOTSTRAP_HASKELL_GHC_VERSION}"
+eghcup --cache install-cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"

 edo cabal new-update

--- a/ghcup-0.0.2.json
+++ b/ghcup-0.0.2.json
@@ -34,14 +34,33 @@
            "notes": ""
          }
        },
+        "Linux_Debian": {
+          "unknown_versioning": {
+            "distroPKGs": [
+              "build-essential",
+              "curl",
+              "libffi-dev",
+              "libffi6",
+              "libgmp-dev",
+              "libgmp10",
+              "libncurses-dev",
+              "libncurses5",
+              "libtinfo5"
+            ],
+            "notes": ""
+          }
+        },
        "Linux_Ubuntu": {
          "unknown_versioning": {
            "distroPKGs": [
              "build-essential",
              "curl",
-              "libgmp-dev",
              "libffi-dev",
+              "libffi6",
+              "libgmp-dev",
+              "libgmp10",
              "libncurses-dev",
+              "libncurses5",
              "libtinfo5"
            ],
            "notes": ""
--- a/ghcup.cabal
+++ b/ghcup.cabal
@@ -327,6 +327,7 @@ executable ghcup
    , pretty-terminal
    , resourcet
    , safe
+    , safe-exceptions
    , string-interpolate
    , table-layout
    , template-haskell
--- a/lib/GHCup.hs
+++ b/lib/GHCup.hs
@@ -38,6 +38,7 @@ import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
                                         hiding ( throwM )
 import           Data.ByteString                ( ByteString )
+import           Data.Either
 import           Data.List
 import           Data.Maybe
 import           Data.String.Interpolate
@@ -53,6 +54,7 @@ import           Prelude                 hiding ( abs
                                                , readFile
                                                , writeFile
                                                )
+import           Safe                    hiding ( at )
 import           System.IO.Error
 import           System.Posix.Env.ByteString    ( getEnvironment )
 import           System.Posix.FilePath          ( getSearchPath )
@@ -148,24 +150,39 @@ installCabalBin :: ( MonadMask m
                   , MonadLogger m
                   , MonadResource m
                   , MonadIO m
+                   , MonadFail m
                   )
                => GHCupDownloads
                -> Version
                -> Maybe PlatformRequest -- ^ if Nothing, looks up current host platform
                -> Excepts
-                     '[ CopyError
+                     '[ AlreadyInstalled
+                      , CopyError
                      , DigestError
                      , DistroNotFound
                      , DownloadFailed
                      , NoCompatibleArch
                      , NoCompatiblePlatform
                      , NoDownload
+                      , NotInstalled
                      , UnknownArchive
                      ]
                     m
                     ()
 installCabalBin bDls ver mpfReq = do
  lift $ $(logDebug) [i|Requested to install cabal version #{ver}|]
+
+  bindir <- liftIO ghcupBinDir
+
+  whenM
+      (liftIO $ cabalInstalled ver >>= \a ->
+        handleIO (\_ -> pure False)
+          $ fmap (\x -> a && isSymbolicLink x)
+          -- ignore when the installation is a legacy cabal (binary, not symlink)
+          $ getSymbolicLinkStatus (toFilePath (bindir </> [rel|cabal|]))
+      )
+    $ (throwE $ AlreadyInstalled Cabal ver)
+
  Settings {..}                <- lift ask
  pfreq@(PlatformRequest {..}) <- maybe (liftE $ platformRequest) pure mpfReq

@@ -178,13 +195,16 @@ installCabalBin bDls ver mpfReq = do
  liftE $ unpackToDir tmpUnpack dl
  void $ liftIO $ darwinNotarization _rPlatform tmpUnpack

-  -- prepare paths
-  bindir <- liftIO ghcupBinDir
-
  -- the subdir of the archive where we do the work
  let workdir = maybe tmpUnpack (tmpUnpack </>) (view dlSubdir dlinfo)

  liftE $ installCabal' workdir bindir
+
+  -- create symlink if this is the latest version
+  cVers <- liftIO $ fmap rights $ getInstalledCabals
+  let lInstCabal = headMay . reverse . sort $ cVers
+  when (maybe True (ver >=) lInstCabal) $ liftE $ setCabal ver
+
  pure ()

 where
@@ -197,16 +217,17 @@ installCabalBin bDls ver mpfReq = do
    lift $ $(logInfo) "Installing cabal"
    let cabalFile = [rel|cabal|]
    liftIO $ createDirIfMissing newDirPerms inst
+    destFileName <- lift $ parseRel (toFilePath cabalFile <> "-" <> verToBS ver)
    handleIO (throwE . CopyError . show) $ liftIO $ copyFile
      (path </> cabalFile)
-      (inst </> cabalFile)
+      (inst </> destFileName)
      Overwrite



-    ---------------
-    --[ Set GHC ]--
-    ---------------
+    ---------------------
+    --[ Set GHC/cabal ]--
+    ---------------------



@@ -283,6 +304,40 @@ setGHC ver sghc = do



+-- | Set the ~/.ghcup/bin/cabal symlink.
+setCabal :: (MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
+         => Version
+         -> Excepts '[NotInstalled] m ()
+setCabal ver = do
+  let verBS = verToBS ver
+  targetFile <- parseRel ("cabal-" <> verBS)
+
+  -- symlink destination
+  bindir     <- liftIO $ ghcupBinDir
+  liftIO $ hideError AlreadyExists $ createDirRecursive newDirPerms bindir
+
+  whenM (liftIO $ fmap not $ doesFileExist (bindir </> targetFile))
+    $ throwE
+    $ NotInstalled Cabal (prettyVer ver)
+
+  let cabalbin = bindir </> [rel|cabal|]
+
+  -- delete old file (may be binary or symlink)
+  lift $ $(logDebug) [i|rm -f #{toFilePath cabalbin}|]
+  liftIO $ hideError doesNotExistErrorType $ deleteFile
+    cabalbin
+
+  -- create symlink
+  let destL = toFilePath targetFile
+  lift $ $(logDebug) [i|ln -s #{destL} #{toFilePath cabalbin}|]
+  liftIO $ createSymlink cabalbin destL
+
+  pure ()
+
+
+
+
+

    ------------------
    --[ List tools ]--
@@ -302,6 +357,7 @@ data ListResult = ListResult
  , lSet       :: Bool -- ^ currently active version
  , fromSrc    :: Bool -- ^ compiled from source
  , lStray     :: Bool -- ^ not in download info
+  , lNoBindist :: Bool -- ^ whether the version is available for this platform/arch
  }
  deriving (Eq, Ord, Show)

@@ -314,28 +370,41 @@ availableToolVersions av tool = view

 -- | List all versions from the download info, as well as stray
 -- versions.
-listVersions :: (MonadThrow m, MonadLogger m, MonadIO m)
+listVersions :: ( MonadCatch m
+                , MonadLogger m
+                , MonadThrow m
+                , MonadLogger m
+                , MonadIO m
+                )
             => GHCupDownloads
             -> Maybe Tool
             -> Maybe ListCriteria
-             -> m [ListResult]
-listVersions av lt criteria = case lt of
-  Just t -> do
-    -- get versions from GHCupDownloads
-    let avTools = availableToolVersions av t
-    lr <- filter' <$> forM (Map.toList avTools) (liftIO . toListResult t)
+             -> Excepts
+                  '[ NoCompatiblePlatform
+                   , NoCompatibleArch
+                   , DistroNotFound
+                   ]
+                  m
+                  [ListResult]
+listVersions av lt criteria = do
+  pfreq <- platformRequest
+  case lt of
+    Just t -> do
+      -- get versions from GHCupDownloads
+      let avTools = availableToolVersions av t
+      lr <- filter' <$> forM (Map.toList avTools) (liftIO . toListResult pfreq t)

-    case t of
-      -- append stray GHCs
-      GHC -> do
-        slr <- strayGHCs avTools
-        pure $ (sort (slr ++ lr))
-      _ -> pure lr
-  Nothing -> do
-    ghcvers   <- listVersions av (Just GHC) criteria
-    cabalvers <- listVersions av (Just Cabal) criteria
-    ghcupvers <- listVersions av (Just GHCup) criteria
-    pure (ghcvers <> cabalvers <> ghcupvers)
+      case t of
+        -- append stray GHCs
+        GHC -> do
+          slr <- lift $ strayGHCs avTools
+          pure $ (sort (slr ++ lr))
+        _ -> pure lr
+    Nothing -> do
+      ghcvers   <- listVersions av (Just GHC) criteria
+      cabalvers <- listVersions av (Just Cabal) criteria
+      ghcupvers <- listVersions av (Just GHCup) criteria
+      pure (ghcvers <> cabalvers <> ghcupvers)

 where
  strayGHCs :: (MonadThrow m, MonadLogger m, MonadIO m)
@@ -357,6 +426,7 @@ listVersions av lt criteria = case lt of
              , lTag       = []
              , lInstalled = True
              , lStray     = maybe True (const False) (Map.lookup _tvVersion avTools)
+              , lNoBindist = False
              , ..
              }
      Right tver@GHCTargetVersion{ .. } -> do
@@ -369,6 +439,7 @@ listVersions av lt criteria = case lt of
          , lTag       = []
          , lInstalled = True
          , lStray     = True -- NOTE: cross currently cannot be installed via bindist
+          , lNoBindist = False
          , ..
          }
      Left e -> do
@@ -377,17 +448,19 @@ listVersions av lt criteria = case lt of
        pure Nothing

  -- NOTE: this are not cross ones, because no bindists
-  toListResult :: Tool -> (Version, [Tag]) -> IO ListResult
-  toListResult t (v, tags) = case t of
+  toListResult :: PlatformRequest -> Tool -> (Version, [Tag]) -> IO ListResult
+  toListResult pfreq t (v, tags) = case t of
    GHC -> do
+      let lNoBindist = isLeft $ getDownloadInfo GHC v pfreq av
      let tver = mkTVer v
      lSet       <- fmap (maybe False (\(GHCTargetVersion _ v') -> v' == v)) $ ghcSet Nothing
      lInstalled <- ghcInstalled tver
      fromSrc    <- ghcSrcInstalled tver
      pure ListResult { lVer = v, lCross = Nothing , lTag = tags, lTool = t, lStray = False, .. }
    Cabal -> do
-      lSet <- fmap (== v) $ cabalSet
-      let lInstalled = lSet
+      let lNoBindist = isLeft $ getDownloadInfo Cabal v pfreq av
+      lSet <- fmap (maybe False (== v)) $ cabalSet
+      lInstalled <- cabalInstalled v
      pure ListResult { lVer    = v
                      , lCross  = Nothing
                      , lTag    = tags
@@ -405,6 +478,7 @@ listVersions av lt criteria = case lt of
                      , lTool   = t
                      , fromSrc = False
                      , lStray  = False
+                      , lNoBindist = False
                      , ..
                      }

@@ -417,9 +491,9 @@ listVersions av lt criteria = case lt of



-    --------------
-    --[ GHC rm ]--
-    --------------
+    --------------------
+    --[ GHC/cabal rm ]--
+    --------------------


 -- | This function may throw and crash in various ways.
@@ -461,6 +535,26 @@ rmGHCVer ver = do
    else throwE (NotInstalled GHC (ver ^. tvVersion % to prettyVer))


+-- | This function may throw and crash in various ways.
+rmCabalVer :: (MonadThrow m, MonadLogger m, MonadIO m, MonadFail m)
+           => Version
+           -> Excepts '[NotInstalled] m ()
+rmCabalVer ver = do
+  whenM (fmap not $ liftIO $ cabalInstalled ver) $ throwE (NotInstalled GHC (prettyVer ver))
+
+  cSet      <- liftIO cabalSet
+
+  bindir    <- liftIO ghcupBinDir
+  cabalFile <- lift $ parseRel ("cabal-" <> verToBS ver)
+  liftIO $ hideError doesNotExistErrorType $ deleteFile (bindir </> cabalFile)
+
+  when (maybe False (== ver) cSet) $ do
+    cVers <- liftIO $ fmap rights $ getInstalledCabals
+    case headMay . reverse . sort $ cVers of
+      Just latestver -> setCabal latestver
+      Nothing        -> liftIO $ hideError doesNotExistErrorType $ deleteFile
+        (bindir </> [rel|cabal|])
+


    ------------------
@@ -671,26 +765,29 @@ Stage1Only = YES|]



-
 compileCabal :: ( MonadReader Settings m
                , MonadResource m
                , MonadMask m
                , MonadLogger m
                , MonadIO m
+                , MonadFail m
                )
             => GHCupDownloads
-             -> Version          -- ^ version to install
+             -> Version                    -- ^ version to install
             -> Either Version (Path Abs)  -- ^ version to bootstrap with
             -> Maybe Int
             -> Maybe (Path Abs)
             -> Excepts
-                  '[ BuildFailed
+                  '[ AlreadyInstalled
+                   , BuildFailed
+                   , CopyError
                   , DigestError
                   , DistroNotFound
                   , DownloadFailed
                   , NoCompatibleArch
                   , NoCompatiblePlatform
                   , NoDownload
+                   , NotInstalled
                   , PatchFailed
                   , UnknownArchive
                   ]
@@ -699,6 +796,17 @@ compileCabal :: ( MonadReader Settings m
 compileCabal dls tver bghc jobs patchdir = do
  lift $ $(logDebug) [i|Requested to compile: #{tver} with ghc-#{bghc}|]

+  bindir <- liftIO ghcupBinDir
+
+  whenM
+      (liftIO $ cabalInstalled tver >>= \a ->
+        handleIO (\_ -> pure False)
+          $ fmap (\x -> a && isSymbolicLink x)
+          -- ignore when the installation is a legacy cabal (binary, not symlink)
+          $ getSymbolicLinkStatus (toFilePath (bindir </> [rel|cabal|]))
+      )
+    $ (throwE $ AlreadyInstalled Cabal tver)
+
  -- download source tarball
  dlInfo <- preview (ix Cabal % ix tver % viSourceDL % _Just) dls ?? NoDownload
  dl <- liftE $ downloadCached dlInfo Nothing
@@ -711,21 +819,25 @@ compileCabal dls tver bghc jobs patchdir = do

  let workdir = maybe id (flip (</>)) (view dlSubdir dlInfo) $ tmpUnpack

+  cbin         <- liftE $ runBuildAction tmpUnpack Nothing (compile workdir)

-  liftE $ runBuildAction
-    tmpUnpack
-    Nothing
-    (compile workdir)
+  destFileName <- lift $ parseRel ("cabal-" <> verToBS tver)
+  handleIO (throwE . CopyError . show) $ liftIO $ copyFile
+    cbin
+    (bindir </> destFileName)
+    Overwrite

-  -- only clean up dir if the build succeeded
-  liftIO $ deleteDirRecursive tmpUnpack
+  -- create symlink if this is the latest version
+  cVers <- liftIO $ fmap rights $ getInstalledCabals
+  let lInstCabal = headMay . reverse . sort $ cVers
+  when (maybe True (tver >=) lInstCabal) $ liftE $ setCabal tver

  pure ()

 where
-  compile :: (MonadThrow m, MonadLogger m, MonadIO m)
+  compile :: (MonadThrow m, MonadLogger m, MonadIO m, MonadResource m)
          => Path Abs
-          -> Excepts '[ProcessError , PatchFailed] m ()
+          -> Excepts '[ProcessError , PatchFailed] m (Path Abs)
  compile workdir = do
    lift $ $(logInfo) [i|Building (this may take a while)...|]

@@ -741,14 +853,19 @@ compileCabal dls tver bghc jobs patchdir = do
        pure
          [ ("GHC"    , toFilePath path)
          , ("GHC_PKG", dn <> "/" <> "ghc-pkg" <> ver)
+          , ("HADDOCK", dn <> "/" <> "haddock" <> ver)
          ]
      Left bver -> do
        let v' = verToBS bver
-        pure [("GHC", "ghc-" <> v'), ("GHC_PKG", "ghc-pkg-" <> v')]
+        pure
+          [ ("GHC"    , "ghc-" <> v')
+          , ("GHC_PKG", "ghc-pkg-" <> v')
+          , ("HADDOCK", "haddock-" <> v')
+          ]

-    cabal_bin <- liftIO $ ghcupBinDir
-    newEnv    <- lift
-      $ addToCurrentEnv (("PREFIX", toFilePath cabal_bin) : ghcEnv)
+    tmp <- lift withGHCupTmpDir
+    liftIO $ createDirRecursive newDirPerms (tmp </> [rel|bin|])
+    newEnv <- lift $ addToCurrentEnv (("PREFIX", toFilePath tmp) : ghcEnv)
    lift $ $(logDebug) [i|Environment: #{newEnv}|]

    lEM $ liftIO $ execLogged "./bootstrap.sh"
@@ -757,6 +874,7 @@ compileCabal dls tver bghc jobs patchdir = do
                              [rel|cabal-bootstrap|]
                              (Just workdir)
                              (Just newEnv)
+    pure $ (tmp </> [rel|bin/cabal|])



--- a/lib/GHCup/Data/ToolRequirements.hs
+++ b/lib/GHCup/Data/ToolRequirements.hs
@@ -53,9 +53,30 @@ toolRequirements = M.fromList
                , Requirements
                  [ "build-essential"
                  , "curl"
-                  , "libgmp-dev"
                  , "libffi-dev"
+                  , "libffi6"
+                  , "libgmp-dev"
+                  , "libgmp10"
                  , "libncurses-dev"
+                  , "libncurses5"
+                  , "libtinfo5"
+                  ]
+                  ""
+                )
+              ]
+            )
+          , ( Linux Debian
+            , M.fromList
+              [ ( Nothing
+                , Requirements
+                  [ "build-essential"
+                  , "curl"
+                  , "libffi-dev"
+                  , "libffi6"
+                  , "libgmp-dev"
+                  , "libgmp10"
+                  , "libncurses-dev"
+                  , "libncurses5"
                  , "libtinfo5"
                  ]
                  ""
--- a/lib/GHCup/Utils.hs
+++ b/lib/GHCup/Utils.hs
@@ -210,19 +210,41 @@ getInstalledGHCs = do
    Left  _ -> pure $ Left f


+getInstalledCabals :: IO [Either (Path Rel) Version]
+getInstalledCabals = do
+  bindir <- liftIO $ ghcupBinDir
+  bins   <- liftIO $ handleIO (\_ -> pure []) $ findFiles
+    bindir
+    (makeRegexOpts compExtended execBlank ([s|^cabal-.*$|] :: ByteString))
+  vs <- forM bins $ \f -> case fmap version (fmap decUTF8Safe . B.stripPrefix "cabal-" . toFilePath $ f) of
+    Just (Right r) -> pure $ Right r
+    Just (Left  _) -> pure $ Left f
+    Nothing        -> pure $ Left f
+  cs <- cabalSet -- for legacy cabal
+  pure $ maybe vs (\x -> Right x:vs) cs
+
+
 cabalInstalled :: Version -> IO Bool
 cabalInstalled ver = do
-  reportedVer <- cabalSet
-  pure (reportedVer == ver)
+  vers <- fmap rights $ getInstalledCabals
+  pure $ elem ver $ vers

-cabalSet :: (MonadIO m, MonadThrow m) => m Version
+
+cabalSet :: (MonadIO m, MonadThrow m) => m (Maybe Version)
 cabalSet = do
  cabalbin <- (</> [rel|cabal|]) <$> liftIO ghcupBinDir
-  mc       <- liftIO $ executeOut cabalbin ["--numeric-version"] Nothing
-  let reportedVer = fst . B.spanEnd (== _lf) . _stdOut $ mc
-  case version $ decUTF8Safe reportedVer of
-    Left  e -> throwM e
-    Right r -> pure r
+  mc       <- liftIO $ handleIO (\_ -> pure Nothing) $ fmap Just $ executeOut
+    cabalbin
+    ["--numeric-version"]
+    Nothing
+  fmap join $ forM mc $ \c -> if
+             | not (B.null (_stdOut c))
+             , _exitCode c == ExitSuccess -> do
+                  let reportedVer = fst . B.spanEnd (== _lf) . _stdOut $ c
+                  case version $ decUTF8Safe reportedVer of
+                    Left  e -> throwM e
+                    Right r -> pure $ Just r
+             | otherwise -> pure Nothing



@@ -463,11 +485,11 @@ getChangeLog dls tool (Right tag) =
 runBuildAction :: (Show (V e), MonadReader Settings m, MonadIO m, MonadMask m)
               => Path Abs          -- ^ build directory
               -> Maybe (Path Abs)  -- ^ install location (e.g. for GHC)
-               -> Excepts e m ()
-               -> Excepts '[BuildFailed] m ()
+               -> Excepts e m a
+               -> Excepts '[BuildFailed] m a
 runBuildAction bdir instdir action = do
  Settings {..} <- lift ask
-  flip
+  v <- flip
      onException
      (do
        forM_ instdir $ \dir ->
@@ -491,3 +513,4 @@ runBuildAction bdir instdir action = do

  when (keepDirs == Never || keepDirs == Errors) $ liftIO $ deleteDirRecursive
    bdir
+  pure v
Author	SHA1	Message	Date
Julian Ospald	939ebdee0e	Update travis	2020-06-14 12:36:13 +02:00
Julian Ospald	8f4ef48891	Merge remote-tracking branch 'origin/merge-requests/10'	2020-06-14 11:50:02 +02:00
Artur Gajowy	d852ab3415	Use `BOOTSTAP_HASKELL_{GHC,CABAL}_VERSION` env vars as overrides	2020-06-14 00:15:50 +02:00
Julian Ospald	a1bcc4b51f	Strip release binaries	2020-05-30 22:15:48 +02:00
Julian Ospald	be93a98bd4	Update ToolRequirements for Ubuntu, add Debian Fixes #26	2020-05-17 18:43:58 +02:00
Julian Ospald	85054d9c76	Show note for versions that don't have a bindist	2020-05-15 21:53:45 +02:00
Julian Ospald	6c95218daf	Support multiple installed versions of cabal Fixes #23	2020-05-13 21:33:45 +02:00