Add changelog

Update HLS doc link
Merge branch 'issue-391'
2022-07-29 21:52:56 +08:00 · 2022-07-27 23:29:33 +08:00 · 2022-07-25 20:33:21 +08:00 · 2022-07-25 17:57:10 +08:00 · 2022-07-24 20:24:00 +08:00 · 2022-07-23 21:32:15 +01:00
14 changed files with 420 additions and 95 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,32 @@
 # Revision history for ghcup

+## 0.1.18.0 -- 2022-07-30
+
+* Fix tui set wrt [#266](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/266) by Arjun Kathuria
+    - Ask the user to install the tool via prompt when setting an non-installed version
+* improvements to safe (un-)installations
+    - bindists that don't support `make DESTDIR=/some/tmp/dir install` are now unsupported
+    - installed GHC files are now recorded to avoid use of `removePathForcibly`
+    - internally uses a newtype wrapper for user-input paths and restrict destructive operations to validated paths
+* use of `TMPDIR` is dropped... now uses an internal tmp dir `~/.ghcup/tmp`
+* improvements to error handling and warnings
+* Require --isolate to have an absolute directory, fixes #367
+* Fix mingw PATH handling wrt #371
+* Add --mingw-path switch to `ghcup run`
+* Fix `ghcup run` on windows, fixes #375
+* Allow passing bindist configure args wrt #377
+* Improve `ghcup compile hls`
+    - short hashes now work
+    - print the long hash in addition to the detected cabal version of HLS
+    - add `--git-describe-version` switch as an alternative to `--overwrite-version`
+    - Allow to build HLS from hackage (now is the default)
+	- Allow to run 'cabal update' automatically before the HLS build
+	- Fix parser and completer for 'ghcup compile hls --version'
+* Improve `ghcup compile ghc`
+    - short hashes now work
+    - print the long hash in addition to the detected cabal version of HLS
+    - Allow to build from arbitrary GHC source dists
+
 ## 0.1.17.10 -- 2022-05-12

 * windows hotfix (hackage-only release)
--- a/app/ghcup/BrickMain.hs
+++ b/app/ghcup/BrickMain.hs
@@ -17,6 +17,7 @@ import           GHCup.Prelude ( decUTF8Safe )
 import           GHCup.Prelude.File
 import           GHCup.Prelude.Logger
 import           GHCup.Prelude.Process
+import           GHCup.Prompts

 import           Brick
 import           Brick.Widgets.Border
@@ -52,6 +53,8 @@ import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           URI.ByteString

 import qualified Data.Text                     as T
+import qualified Data.Text.Lazy.Builder        as B
+import qualified Data.Text.Lazy                as L
 import qualified Graphics.Vty                  as Vty
 import qualified Data.Vector                   as V
 import System.Environment (getExecutablePath)
@@ -98,7 +101,7 @@ keyHandlers KeyBindings {..} =
  [ (bQuit, const "Quit"     , halt)
  , (bInstall, const "Install"  , withIOAction install')
  , (bUninstall, const "Uninstall", withIOAction del')
-  , (bSet, const "Set"      , withIOAction ((liftIO .) . set'))
+  , (bSet, const "Set"      , withIOAction set')
  , (bChangelog, const "ChangeLog", withIOAction changelog')
  , ( bShowAllVersions
    , \BrickSettings {..} ->
@@ -486,9 +489,12 @@ install' _ (_, ListResult {..}) = do
            <> "Also check the logs in ~/.ghcup/logs"


-set' :: BrickState -> (Int, ListResult) -> IO (Either String ())
-set' _ (_, ListResult {..}) = do
-  settings <- readIORef settings'
+set' :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadFail m, MonadMask m, MonadUnliftIO m)
+     => BrickState
+     -> (Int, ListResult)
+     -> m (Either String ())
+set' bs input@(_, ListResult {..}) = do
+  settings <- liftIO $ readIORef settings'

  let run =
        flip runReaderT settings
@@ -504,7 +510,28 @@ set' _ (_, ListResult {..}) = do
    )
    >>= \case
          VRight _ -> pure $ Right ()
-          VLeft  e -> pure $ Left (prettyShow e)
+          VLeft  e -> case e of
+            (V (NotInstalled tool _)) -> do
+              promptAnswer <- getUserPromptResponse userPrompt
+              case promptAnswer of
+                PromptYes -> do
+                  res <- install' bs input
+                  case res of
+                    (Left err) -> pure $ Left err
+                    (Right _) -> do
+                      logInfo "Setting now..."
+                      set' bs input
+
+                PromptNo -> pure $ Left (prettyShow e)
+              where
+                userPrompt = L.toStrict . B.toLazyText . B.fromString $
+                  "This Version of "
+                  <> show tool
+                  <> " you are trying to set is not installed.\n"
+                  <> "Would you like to install it first? [Y/N]: "
+
+            _ -> pure $ Left (prettyShow e)
+


 del' :: (MonadReader AppState m, MonadIO m, MonadFail m, MonadMask m, MonadUnliftIO m)
--- a/app/ghcup/GHCup/OptParse/Common.hs
+++ b/app/ghcup/GHCup/OptParse/Common.hs
@@ -452,9 +452,11 @@ tagCompleter tool add = listIOCompleter $ do
      pure $ nub $ (add ++) $ fmap tagToString allTags
    VLeft _ -> pure  (nub $ ["recommended", "latest"] ++ add)

-
 versionCompleter :: Maybe ListCriteria -> Tool -> Completer
-versionCompleter criteria tool = listIOCompleter $ do
+versionCompleter criteria tool = versionCompleter' criteria tool (const True)
+
+versionCompleter' :: Maybe ListCriteria -> Tool -> (Version -> Bool) -> Completer
+versionCompleter' criteria tool filter' = listIOCompleter $ do
  dirs' <- liftIO getAllDirs
  let loggerConfig = LoggerConfig
        { lcPrintDebug   = False
@@ -483,7 +485,7 @@ versionCompleter criteria tool = listIOCompleter $ do
          runEnv = flip runReaderT appState

      installedVersions <- runEnv $ listVersions (Just tool) criteria
-      return $ T.unpack . prettyVer . lVer <$> installedVersions
+      return $ fmap (T.unpack . prettyVer) . filter filter' . fmap lVer $ installedVersions


 toolDlCompleter :: Tool -> Completer
--- a/app/ghcup/GHCup/OptParse/Compile.hs
+++ b/app/ghcup/GHCup/OptParse/Compile.hs
@@ -12,6 +12,8 @@ module GHCup.OptParse.Compile where


 import           GHCup
+import qualified GHCup.GHC as GHC
+import qualified GHCup.HLS as HLS
 import           GHCup.Errors
 import           GHCup.Types
 import           GHCup.Types.Optics
@@ -30,7 +32,8 @@ import           Control.Monad.Trans.Resource
 import           Data.Bifunctor
 import           Data.Functor
 import           Data.Maybe
-import           Data.Versions                  ( Version, prettyVer, version )
+import           Data.Versions                  ( Version, prettyVer, version, pvp )
+import qualified Data.Versions as V
 import           Data.Text                      ( Text )
 import           Haskus.Utils.Variant.Excepts
 import           Options.Applicative     hiding ( style )
@@ -41,7 +44,7 @@ import           Text.PrettyPrint.HughesPJClass ( prettyShow )

 import           URI.ByteString          hiding ( uriParser )
 import qualified Data.Text                     as T
-import Control.Exception.Safe (MonadMask)
+import Control.Exception.Safe (MonadMask, displayException)
 import System.FilePath (isPathSeparator)
 import Text.Read (readEither)

@@ -64,7 +67,7 @@ data CompileCommand = CompileGHC GHCCompileOptions


 data GHCCompileOptions = GHCCompileOptions
-  { targetGhc    :: Either Version GitBranch
+  { targetGhc    :: GHC.GHCVer Version
  , bootstrapGhc :: Either Version FilePath
  , jobs         :: Maybe Int
  , buildConfig  :: Maybe FilePath
@@ -78,10 +81,12 @@ data GHCCompileOptions = GHCCompileOptions
  , isolateDir   :: Maybe FilePath
  }

+
 data HLSCompileOptions = HLSCompileOptions
-  { targetHLS    :: Either Version GitBranch
+  { targetHLS    :: HLS.HLSVer
  , jobs         :: Maybe Int
  , setCompile   :: Bool
+  , updateCabal  :: Bool
  , ovewrwiteVer :: Either Bool Version
  , isolateDir   :: Maybe FilePath
  , cabalProject :: Maybe (Either FilePath URI)
@@ -149,10 +154,10 @@ Examples:
  These need to be available in PATH prior to compilation.

 Examples:
-  # compile 1.7.0.0 for ghc 8.10.5 and 8.10.7, passing '--allow-newer' to cabal
-  ghcup compile hls -v 1.7.0.0 -j 12 --ghc 8.10.5 --ghc 8.10.7 -- --allow-newer
-  # compile from master for ghc 9.2.3 and use 'git describe' to name the binary
-  ghcup compile hls -g master --git-describe-version --ghc 9.2.3
+  # compile 1.7.0.0 from hackage for 8.10.7, running 'cabal update' before the build
+  ghcup compile hls --version 1.7.0.0 --ghc 8.10.7 --cabal-update
+  # compile from master for ghc 9.2.3 using 'git describe' to name the binary and ignore the pinned index state
+  ghcup compile hls -g master --git-describe-version --ghc 9.2.3 -- --index-state=@(date '+%s')
  # compile a specific commit for ghc 9.2.3 and set a specifc version for the binary name
  ghcup compile hls -g a32db0b -o 1.7.0.0-p1 --ghc 9.2.3|]

@@ -160,7 +165,7 @@ Examples:
 ghcCompileOpts :: Parser GHCCompileOptions
 ghcCompileOpts =
  GHCCompileOptions
-    <$> ((Left <$> option
+    <$> ((GHC.SourceDist <$> option
          (eitherReader
            (first (const "Not a valid version") . version . T.pack)
          )
@@ -169,7 +174,7 @@ ghcCompileOpts =
            <> (completer $ versionCompleter Nothing GHC)
          )
          ) <|>
-          (Right <$> (GitBranch <$> option
+          (GHC.GitDist <$> (GitBranch <$> option
          str
          (short 'g' <> long "git-ref" <> metavar "GIT_REFERENCE" <> help
            "The git commit/branch/ref to build from"
@@ -178,7 +183,18 @@ ghcCompileOpts =
            short 'r' <> long "repository" <> metavar "GIT_REPOSITORY" <> help "The git repository to build from (defaults to GHC upstream)"
            <> completer (gitFileUri ["https://gitlab.haskell.org/ghc/ghc.git"])
            ))
-          )))
+          ))
+          <|>
+          (
+           GHC.RemoteDist <$> (option
+            (eitherReader uriParser)
+            (long "remote-source-dist" <> metavar "URI" <> help
+              "URI (https/http/file) to a GHC source distribution"
+              <> completer fileUri
+            )
+          )
+          )
+          )
    <*> option
          (eitherReader
            (\x ->
@@ -270,16 +286,17 @@ ghcCompileOpts =
 hlsCompileOpts :: Parser HLSCompileOptions
 hlsCompileOpts =
  HLSCompileOptions
-    <$> ((Left <$> option
+    <$> ((HLS.HackageDist <$> option
          (eitherReader
-            (first (const "Not a valid version") . version . T.pack)
+            ((>>= first displayException . V.version . V.prettyPVP) . first (const "Not a valid PVP version") . pvp . T.pack)
          )
          (short 'v' <> long "version" <> metavar "VERSION" <> help
-            "The tool version to compile"
-            <> (completer $ versionCompleter Nothing HLS)
+            "The version to compile (pulled from hackage)"
+            <> (completer $ versionCompleter' Nothing HLS (either (const False) (const True) . V.pvp . V.prettyVer))
          )
-          ) <|>
-          (Right <$> (GitBranch <$> option
+          )
+          <|>
+          (HLS.GitDist <$> (GitBranch <$> option
          str
          (short 'g' <> long "git-ref" <> metavar "GIT_REFERENCE" <> help
            "The git commit/branch/ref to build from (accepts anything 'git checkout' accepts)"
@@ -287,7 +304,28 @@ hlsCompileOpts =
          optional (option str (short 'r' <> long "repository" <> metavar "GIT_REPOSITORY" <> help "The git repository to build from (defaults to HLS upstream)"
            <> completer (gitFileUri ["https://github.com/haskell/haskell-language-server.git"])
          ))
-          )))
+          ))
+          <|>
+          (HLS.SourceDist <$> (option
+            (eitherReader
+              (first (const "Not a valid version") . version . T.pack)
+            )
+          (long "source-dist" <> metavar "VERSION" <> help
+            "The version to compile (pulled from packaged git sources)"
+            <> (completer $ versionCompleter Nothing HLS)
+          )
+          ))
+          <|>
+          (
+           HLS.RemoteDist <$> (option
+            (eitherReader uriParser)
+            (long "remote-source-dist" <> metavar "URI" <> help
+              "URI (https/http/file) to a HLS source distribution"
+              <> completer fileUri
+            )
+          )
+          )
+          )
    <*> optional
          (option
            (eitherReader (readEither @Int))
@@ -297,6 +335,7 @@ hlsCompileOpts =
            )
          )
    <*> fmap (fromMaybe True) (invertableSwitch "set" Nothing True (help "Don't set as active version after install"))
+    <*> switch (long "cabal-update" <> help "Run 'cabal update' before the build")
    <*>
         (
          (Right <$> option
@@ -468,7 +507,7 @@ compile compileCommand settings Dirs{..} runAppState runLogger = do
    (CompileHLS HLSCompileOptions { .. }) -> do
      runCompileHLS runAppState (do
        case targetHLS of
-          Left targetVer -> do
+          HLS.SourceDist targetVer -> do
            GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
            let vi = getVersionInfo targetVer HLS dls
            forM_ (_viPreCompile =<< vi) $ \msg -> do
@@ -476,7 +515,7 @@ compile compileCommand settings Dirs{..} runAppState runLogger = do
              lift $ logInfo
                "...waiting for 5 seconds, you can still abort..."
              liftIO $ threadDelay 5000000 -- for compilation, give the user a sec to intervene
-          Right _ -> pure ()
+          _ -> pure ()
        ghcs <- liftE $ forM targetGHCs (\ghc -> fmap (_tvVersion . fst) . fromVersion (Just ghc) $ GHC)
        targetVer <- liftE $ compileHLS
                    targetHLS
@@ -486,6 +525,7 @@ compile compileCommand settings Dirs{..} runAppState runLogger = do
                    (maybe GHCupInternal IsolateDir isolateDir)
                    cabalProject
                    cabalProjectLocal
+                    updateCabal
                    patches
                    cabalArgs
        GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
@@ -519,7 +559,7 @@ compile compileCommand settings Dirs{..} runAppState runLogger = do
    (CompileGHC GHCCompileOptions {..}) ->
      runCompileGHC runAppState (do
        case targetGhc of
-          Left targetVer -> do
+          GHC.SourceDist targetVer -> do
            GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
            let vi = getVersionInfo targetVer GHC dls
            forM_ (_viPreCompile =<< vi) $ \msg -> do
@@ -527,9 +567,12 @@ compile compileCommand settings Dirs{..} runAppState runLogger = do
              lift $ logInfo
                "...waiting for 5 seconds, you can still abort..."
              liftIO $ threadDelay 5000000 -- for compilation, give the user a sec to intervene
-          Right _ -> pure ()
+          _ -> pure ()
        targetVer <- liftE $ compileGHC
-                    (first (GHCTargetVersion crossTarget) targetGhc)
+                    ((\case
+                        GHC.SourceDist v -> GHC.SourceDist $ GHCTargetVersion crossTarget v
+                        GHC.GitDist g -> GHC.GitDist g
+                        GHC.RemoteDist r -> GHC.RemoteDist r) targetGhc)
                    ovewrwiteVer
                    bootstrapGhc
                    jobs
--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
@@ -14,6 +14,8 @@ module Main where
 import           BrickMain                    ( brickMain )
 #endif

+import qualified GHCup.GHC as GHC
+import qualified GHCup.HLS as HLS
 import           GHCup.OptParse

 import           GHCup.Download
@@ -338,11 +340,13 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
  alreadyInstalling (Install (Left (InstallStack InstallOptions{..})))   (Stack, ver) = cmp' Stack instVer ver
  alreadyInstalling (Compile (CompileGHC GHCCompileOptions{ ovewrwiteVer = Just over }))
    (GHC, ver)   = cmp' GHC (Just $ GHCVersion (mkTVer over)) ver
-  alreadyInstalling (Compile (CompileGHC GHCCompileOptions{ targetGhc = Left tver }))
+  alreadyInstalling (Compile (CompileGHC GHCCompileOptions{ targetGhc = GHC.SourceDist tver }))
    (GHC, ver)   = cmp' GHC (Just $ ToolVersion tver) ver
  alreadyInstalling (Compile (CompileHLS HLSCompileOptions{ ovewrwiteVer = Right over }))
    (HLS, ver)   = cmp' HLS (Just $ ToolVersion over) ver
-  alreadyInstalling (Compile (CompileHLS HLSCompileOptions{ targetHLS = Left tver }))
+  alreadyInstalling (Compile (CompileHLS HLSCompileOptions{ targetHLS = HLS.SourceDist tver }))
+    (HLS, ver)   = cmp' HLS (Just $ ToolVersion tver) ver
+  alreadyInstalling (Compile (CompileHLS HLSCompileOptions{ targetHLS = HLS.HackageDist tver }))
    (HLS, ver)   = cmp' HLS (Just $ ToolVersion tver) ver
  alreadyInstalling (Upgrade {}) (GHCup, _) = pure True
  alreadyInstalling _ _ = pure False
--- a/docs/guide.md
+++ b/docs/guide.md
@@ -4,7 +4,7 @@ This is a more in-depth guide specific to GHCup. `ghcup --help` is your friend.

 ## Basic usage

-For the simple interactive TUI (not available on windows), run:
+For the simple, interactive, text-based user interface (TUI) (not available on windows), run:

 ```sh
 ghcup tui
@@ -186,6 +186,51 @@ url-source:

 # More on installation

+## Customisation of the installation scripts
+
+The scripts offered to install GHCup are available here:
+
+* [bootstrap-haskell](https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell#L7)
+  for Unix-like operating systems
+* [bootstrap-haskell.ps1](https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell.ps1#L17)
+  for Windows (PowerShell). This will, in turn, run the final bootstrap script
+  (by default, that for the Unix-like operating systems).
+
+The effect of the scripts can be customised by setting one or more
+`BOOTSTRAP_HASKELL_*` environment variables (as set out in the first script)
+and, in the case of Windows, by specifying parameters (as set out in the
+PowerShell script).
+
+For example, you can toggle:
+
+* non-interactive installation
+* a more verbose installation
+* whether to install only GHCup (and, on Windows, MSYS2)
+* not to trigger the upgrade of GHCup
+* whether to install the latest version of HLS
+* whether to install the latest version of Stack
+* whether to respect the XDG Base Directory Specification
+* whether to adjust (prepend) the PATH in `bashrc`
+* on Windows, whether to adjust MINGW paths in `cabal.config`
+
+You can also specify:
+
+* the GHC version to install
+* the Cabal version to install
+* which downloader to use (the default is `curl`)
+* the base URL for the download of the GHCup binary distribution
+
+On Windows, you can also use the parameters to:
+
+* toggle whether to overwrite a previous installation
+* specify the GHCup installation root directory
+* specify the Cabal root directory
+* specify the directory of an existing installation of MSYS2 (for example,
+  the one supplied by Stack)
+* specify the URL of the final bootstrap script
+* toggle whether to run the final bootstrap script via `bash` (instead of in a
+  new MSYS2 shell)
+
 ## Installing custom bindists

 There are a couple of good use cases to install custom bindists:
@@ -202,7 +247,9 @@ and produce the binaries `ghc-8.10.2-eff` and `ghc-head` respectively.
 GHCup always needs to know which version the bindist corresponds to (this is not automatically
 detected).

-## Compiling GHC from source
+## Compiling from source
+
+### GHC

 Compiling from source is supported for both source tarballs and arbitrary git refs. See `ghcup compile ghc --help`
 for a list of all available options.
@@ -214,6 +261,47 @@ Common `build.mk` options are explained [here](https://gitlab.haskell.org/ghc/gh

 Make sure your system meets all the [prerequisites](https://gitlab.haskell.org/ghc/ghc/-/wikis/building/preparation).

+### HLS
+
+There are 3 main ways to compile HLS from source.
+
+1. from hackage (should have up to date version bounds)
+    - `ghcup compile hls --version 1.7.0.0 --ghc 9.2.3`
+2. from git (allows to build latest sources and PRs)
+    - `ghcup compile hls --git-ref master --ghc 9.2.3`
+    - `ghcup compile hls --git-ref a32db0b --ghc 9.2.3`
+    - `ghcup compile hls --git-ref 1.7.0.0 --ghc 9.2.3`
+3. from source distribution that's packaged during release from the corresponding git sources
+    - `ghcup compile hls --source-dist 1.7.0.0 --ghc 9.2.3`
+
+All these use `cabal v2-install` under the hood, so all build components are cached.
+You can pass arbitrary arguments to cabal, e.g. set the index state like so:
+
+```sh
+ghcup compile hls --git-ref master --ghc 9.2.3 -- --index-state=2022-06-12T00:00:00Z --allow-newer
+```
+
+You can pass `--ghc <ver>` multiple times to install for many GHCs at once.
+
+When building from git sources, ghcup will auto-detect the HLS version that the git commit corresponds to
+from the `haskell-language-server.cabal` file. This version might not have been updated since the last release.
+If you want to avoid overwriting the existing installed HLS version, you can instruct ghcup to use `git describe`
+to set the HLS version instead:
+
+```sh
+ghcup compile hls --git-ref master --ghc 9.2.3 --git-describe-version
+```
+
+You can also set the version explicitly:
+
+```sh
+ghcup compile hls --git-ref master --ghc 9.2.3 --overwrite-version 1.7.0.0-p1
+```
+
+To instruct cabal to run `cabal update` before building, run `ghcup compile hls --version 1.7.0.0 --ghc 9.2.3 --cabal-update`
+
+As always, check `ghcup compile hls --help`.
+
 ### Cross support

 ghcup can compile and install a cross GHC for any target. However, this
@@ -258,7 +346,9 @@ Examples:

 ## Continuous integration

-On windows, ghcup can be installed automatically on a CI runner non-interactively like so:
+On Windows, GHCup can be installed automatically on a CI runner
+non-interactively, as below. The paramaters to the PowerShell script are
+specified positionally, after `-ArgumentList`:

 ```ps
 Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $false,$true,$true,$false,$false,$false,$false,"C:\"
@@ -270,12 +360,10 @@ On linux/darwin/freebsd, run the following on your runner:
 curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 BOOTSTRAP_HASKELL_MINIMAL=1 sh
 ```

-This will just install `ghcup` and on windows additionally `msys2`.
+This will just install `ghcup` and on Windows additionally MSYS2.

-For the full list of env variables and parameters to tweak the script behavior, see:
-
-* [bootstrap-haskell for linux/darwin/freebsd](https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell#L7)
-* [bootstrap-haskell.ps1 for windows](https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/master/scripts/bootstrap/bootstrap-haskell.ps1#L17)
+See the installation scripts referred to above for the full list of environment
+variables and, in the case of Windows, parameters to tweak the script behavior.

 ### github workflows

--- a/ghcup.cabal
+++ b/ghcup.cabal
@@ -69,6 +69,7 @@ library
    GHCup.Prelude.Process
    GHCup.Prelude.String.QQ
    GHCup.Prelude.Version.QQ
+    GHCup.Prompts
    GHCup.Requirements
    GHCup.Stack
    GHCup.Types
--- a/lib/GHCup.hs
+++ b/lib/GHCup.hs
@@ -33,8 +33,8 @@ module GHCup (


 import           GHCup.Cabal
-import           GHCup.GHC
-import           GHCup.HLS
+import           GHCup.GHC             hiding ( GHCVer(..) )
+import           GHCup.HLS             hiding ( HLSVer(..) )
 import           GHCup.Stack
 import           GHCup.List
 import           GHCup.Download
@@ -206,9 +206,8 @@ rmGhcupDirs = do
      | isWindows = removeDirIfEmptyOrIsSymlink binDir
      | otherwise = do
          isXDGStyle <- liftIO useXDG
-          if not isXDGStyle
-            then removeDirIfEmptyOrIsSymlink binDir
-            else pure ()
+          when (not isXDGStyle) $
+            removeDirIfEmptyOrIsSymlink binDir

    reportRemainingFiles :: (MonadMask m, MonadIO m) => FilePath -> m [FilePath]
    reportRemainingFiles dir = do
--- a/lib/GHCup/GHC.hs
+++ b/lib/GHCup/GHC.hs
@@ -80,6 +80,12 @@ import qualified Data.Text.Encoding            as E
 import qualified Text.Megaparsec               as MP


+data GHCVer v = SourceDist v
+              | GitDist GitBranch
+              | RemoteDist URI
+
+
+
    ---------------------
    --[ Tool fetching ]--
    ---------------------
@@ -295,8 +301,9 @@ installUnpackedGHC path inst ver forceInstall addConfArgs
  | otherwise = do
      PlatformRequest {..} <- lift getPlatformReq

-      let alpineArgs
-           | ver >= [vver|8.2.2|], Linux Alpine <- _rPlatform
+      let ldOverride
+           | ver >= [vver|8.2.2|]
+           , _rPlatform `elem` [Linux Alpine, Darwin]
           = ["--disable-ld-override"]
           | otherwise
           = []
@@ -304,7 +311,7 @@ installUnpackedGHC path inst ver forceInstall addConfArgs
      lift $ logInfo "Installing GHC (this may take a while)"
      lEM $ execLogged "sh"
                       ("./configure" : ("--prefix=" <> fromInstallDir inst)
-                        : (alpineArgs <> (T.unpack <$> addConfArgs))
+                        : (ldOverride <> (T.unpack <$> addConfArgs))
                       )
                       (Just $ fromGHCupPath path)
                       "ghc-configure"
@@ -607,7 +614,7 @@ compileGHC :: ( MonadMask m
              , MonadUnliftIO m
              , MonadFail m
              )
-           => Either GHCTargetVersion GitBranch          -- ^ version to install
+           => GHCVer GHCTargetVersion
           -> Maybe Version            -- ^ overwrite version
           -> Either Version FilePath  -- ^ version to bootstrap with
           -> Maybe Int                -- ^ jobs
@@ -650,7 +657,7 @@ compileGHC targetGhc ov bstrap jobs mbuildConfig patches aargs buildFlavour hadr

    (workdir, tmpUnpack, tver) <- case targetGhc of
      -- unpack from version tarball
-      Left tver -> do
+      SourceDist tver -> do
        lift $ logDebug $ "Requested to compile: " <> tVerToText tver <> " with " <> either prettyVer T.pack bstrap

        -- download source tarball
@@ -671,8 +678,31 @@ compileGHC targetGhc ov bstrap jobs mbuildConfig patches aargs buildFlavour hadr

        pure (workdir, tmpUnpack, tver)

+      RemoteDist uri -> do
+        lift $ logDebug $ "Requested to compile (from uri): " <> T.pack (show uri)
+
+        -- download source tarball
+        tmpDownload <- lift withGHCupTmpDir
+        tmpUnpack <- lift mkGhcupTmpDir
+        tar <- liftE $ download uri Nothing Nothing (fromGHCupPath tmpDownload) Nothing False
+        (bf, tver) <- liftE $ cleanUpOnError @'[UnknownArchive, ArchiveResult, ProcessError] tmpUnpack $ do
+          liftE $ unpackToDir (fromGHCupPath tmpUnpack) tar
+          let regex = [s|^(.*/)*boot$|] :: B.ByteString
+          [bootFile] <- liftIO $ findFilesDeep
+            tmpUnpack
+            (makeRegexOpts compExtended
+                           execBlank
+                           regex
+            )
+          tver <- liftE $ getGHCVer (appendGHCupPath tmpUnpack (takeDirectory bootFile))
+          pure (bootFile, tver)
+
+        let workdir = appendGHCupPath tmpUnpack (takeDirectory bf)
+
+        pure (workdir, tmpUnpack, mkTVer tver)
+
      -- clone from git
-      Right GitBranch{..} -> do
+      GitDist GitBranch{..} -> do
        tmpUnpack <- lift mkGhcupTmpDir
        let git args = execLogged "git" ("--no-pager":args) (Just $ fromGHCupPath tmpUnpack) "git" Nothing
        tver <- reThrowAll @_ @'[PatchFailed, ProcessError, NotFoundInPATH, DigestError, DownloadFailed, GPGError] DownloadFailed $ do
@@ -715,14 +745,7 @@ compileGHC targetGhc ov bstrap jobs mbuildConfig patches aargs buildFlavour hadr
          liftE $ applyAnyPatch patches (fromGHCupPath tmpUnpack)

          -- bootstrap
-          lEM $ execWithGhcEnv "python3" ["./boot"] (Just $ fromGHCupPath tmpUnpack) "ghc-bootstrap"
-          lEM $ execWithGhcEnv "sh" ["./configure"] (Just $ fromGHCupPath tmpUnpack) "ghc-bootstrap"
-          CapturedProcess {..} <- lift $ makeOut
-            ["show!", "--quiet", "VALUE=ProjectVersion" ] (Just $ fromGHCupPath tmpUnpack)
-          tver <- case _exitCode of
-            ExitSuccess -> throwEither . MP.parse ghcProjectVersion "" . T.pack . stripNewlineEnd . T.unpack . decUTF8Safe' $ _stdOut
-            ExitFailure c -> fail ("Could not figure out GHC project version. Exit code was: " <> show c <> ". Error was: " <> T.unpack (decUTF8Safe' _stdErr))
-
+          tver <- liftE $ getGHCVer tmpUnpack
          liftE $ catchWarn $ lEM @_ @'[ProcessError] $ darwinNotarization _rPlatform (fromGHCupPath tmpUnpack)
          lift $ logInfo $ "Examining git ref " <> T.pack ref <> "\n  " <>
                           "GHC version (from Makefile): " <> prettyVer tver <>
@@ -795,11 +818,29 @@ compileGHC targetGhc ov bstrap jobs mbuildConfig patches aargs buildFlavour hadr
    pure installVer

 where
+  getGHCVer :: ( MonadReader env m
+               , HasSettings env
+               , HasDirs env
+               , HasLog env
+               , MonadIO m
+               , MonadThrow m
+               )
+            => GHCupPath
+            -> Excepts '[ProcessError] m Version
+  getGHCVer tmpUnpack = do
+    lEM $ execWithGhcEnv "python3" ["./boot"] (Just $ fromGHCupPath tmpUnpack) "ghc-bootstrap"
+    lEM $ execWithGhcEnv "sh" ["./configure"] (Just $ fromGHCupPath tmpUnpack) "ghc-bootstrap"
+    CapturedProcess {..} <- lift $ makeOut
+      ["show!", "--quiet", "VALUE=ProjectVersion" ] (Just $ fromGHCupPath tmpUnpack)
+    case _exitCode of
+      ExitSuccess -> throwEither . MP.parse ghcProjectVersion "" . T.pack . stripNewlineEnd . T.unpack . decUTF8Safe' $ _stdOut
+      ExitFailure c -> throwE $ NonZeroExit c "make" ["show!", "--quiet", "VALUE=ProjectVersion" ]
+
  defaultConf =
    let cross_mk = $(LitE . StringL <$> (qAddDependentFile "data/build_mk/cross" >> runIO (readFile "data/build_mk/cross")))
        default_mk = $(LitE . StringL <$> (qAddDependentFile "data/build_mk/default" >> runIO (readFile "data/build_mk/default")))
    in case targetGhc of
-         Left (GHCTargetVersion (Just _) _) -> cross_mk
+         SourceDist (GHCTargetVersion (Just _) _) -> cross_mk
         _ -> default_mk

  compileHadrianBindist :: ( MonadReader env m
@@ -976,7 +1017,7 @@ compileGHC targetGhc ov bstrap jobs mbuildConfig patches aargs buildFlavour hadr

   -- for cross, we need Stage1Only
    case targetGhc of
-      Left (GHCTargetVersion (Just _) _) -> when ("Stage1Only = YES" `notElem` lines') $ throwE
+      SourceDist (GHCTargetVersion (Just _) _) -> when ("Stage1Only = YES" `notElem` lines') $ throwE
        (InvalidBuildConfig
          [s|Cross compiling needs to be a Stage1 build, add "Stage1Only = YES" to your config!|]
        )
--- a/lib/GHCup/HLS.hs
+++ b/lib/GHCup/HLS.hs
@@ -71,6 +71,12 @@ import qualified Text.Megaparsec               as MP
 import Text.PrettyPrint.HughesPJClass (prettyShow)


+data HLSVer = SourceDist Version
+            | GitDist GitBranch
+            | HackageDist Version
+            | RemoteDist URI
+
+

    --------------------
    --[ Installation ]--
@@ -324,13 +330,14 @@ compileHLS :: ( MonadMask m
              , MonadUnliftIO m
              , MonadFail m
              )
-           => Either Version GitBranch
+           => HLSVer
           -> [Version]
           -> Maybe Int
           -> Either Bool Version
           -> InstallDir
           -> Maybe (Either FilePath URI)
           -> Maybe URI
+           -> Bool
           -> Maybe (Either FilePath [URI])  -- ^ patches
           -> [Text]                   -- ^ additional args to cabal install
           -> Excepts '[ NoDownload
@@ -343,15 +350,18 @@ compileHLS :: ( MonadMask m
                       , BuildFailed
                       , NotInstalled
                       ] m Version
-compileHLS targetHLS ghcs jobs ov installDir cabalProject cabalProjectLocal patches cabalArgs = do
+compileHLS targetHLS ghcs jobs ov installDir cabalProject cabalProjectLocal updateCabal patches cabalArgs = do
  PlatformRequest { .. } <- lift getPlatformReq
  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
  Dirs { .. } <- lift getDirs

+  when updateCabal $ reThrowAll @_ @'[ProcessError] DownloadFailed $ do
+    lift $ logInfo "Updating cabal DB"
+    lEM $ exec "cabal" ["update"] (Just $ fromGHCupPath tmpDir) Nothing

-  (workdir, tver, git_describe) <- case targetHLS of
+  (workdir, tmpUnpack, tver, git_describe) <- case targetHLS of
    -- unpack from version tarball
-    Left tver -> do
+    SourceDist tver -> do
      lift $ logDebug $ "Requested to compile: " <> prettyVer tver

      -- download source tarball
@@ -369,10 +379,47 @@ compileHLS targetHLS ghcs jobs ov installDir cabalProject cabalProjectLocal patc
                       (liftE . intoSubdir tmpUnpack)
                       (view dlSubdir dlInfo)

-      pure (workdir, tver, Nothing)
+      pure (workdir, tmpUnpack, tver, Nothing)
+
+    HackageDist tver -> do
+      lift $ logDebug $ "Requested to compile (from hackage): " <> prettyVer tver
+
+      -- download source tarball
+      tmpUnpack <- lift mkGhcupTmpDir
+      let hls = "haskell-language-server-" <> T.unpack (prettyVer tver)
+      reThrowAll @_ @'[ProcessError] DownloadFailed $ do
+        -- unpack
+        lEM $ exec "cabal" ["unpack", hls] (Just $ fromGHCupPath tmpUnpack) Nothing
+
+      let workdir = appendGHCupPath tmpUnpack hls
+
+      pure (workdir, tmpUnpack, tver, Nothing)
+
+    RemoteDist uri -> do
+      lift $ logDebug $ "Requested to compile (from uri): " <> T.pack (show uri)
+
+      -- download source tarball
+      tmpDownload <- lift withGHCupTmpDir
+      tmpUnpack <- lift mkGhcupTmpDir
+      tar <- liftE $ download uri Nothing Nothing (fromGHCupPath tmpDownload) Nothing False
+      (cf, tver) <- liftE $ cleanUpOnError tmpUnpack $ do
+        unpackToDir (fromGHCupPath tmpUnpack) tar
+        let regex = [s|^(.*/)*haskell-language-server\.cabal$|] :: B.ByteString
+        [cabalFile] <- liftIO $ findFilesDeep
+          tmpUnpack
+          (makeRegexOpts compExtended
+                         execBlank
+                         regex
+          )
+        tver <- getCabalVersion (fromGHCupPath tmpUnpack </> cabalFile)
+        pure (cabalFile, tver)
+
+      let workdir = appendGHCupPath tmpUnpack (takeDirectory cf)
+
+      pure (workdir, tmpUnpack, tver, Nothing)

    -- clone from git
-    Right GitBranch{..} -> do
+    GitDist GitBranch{..} -> do
      tmpUnpack <- lift mkGhcupTmpDir
      let git args = execLogged "git" ("--no-pager":args) (Just $ fromGHCupPath tmpUnpack) "git" Nothing
      reThrowAll @_ @'[ProcessError] DownloadFailed $ do
@@ -409,15 +456,7 @@ compileHLS targetHLS ghcs jobs ov installDir cabalProject cabalProjectLocal patc
                        then pure Nothing
                        else fmap Just $ gitOut ["describe", "--tags"] (fromGHCupPath tmpUnpack)
        chash <- gitOut ["rev-parse", "HEAD" ] (fromGHCupPath tmpUnpack)
-        (Just gpd) <- parseGenericPackageDescriptionMaybe
-          <$> liftIO (B.readFile (fromGHCupPath tmpUnpack </> "haskell-language-server.cabal"))
-        let tver = (\c -> Version Nothing c [] Nothing)
-                 . NE.fromList . fmap (NE.fromList . (:[]) . digits . fromIntegral)
-                 . versionNumbers
-                 . pkgVersion
-                 . package
-                 . packageDescription
-                 $ gpd
+        tver <- getCabalVersion (fromGHCupPath tmpUnpack </> "haskell-language-server.cabal")

        liftE $ catchWarn $ lEM @_ @'[ProcessError] $ darwinNotarization _rPlatform (fromGHCupPath tmpUnpack)
        lift $ logInfo $ "Examining git ref " <> T.pack ref <> "\n  " <>
@@ -425,7 +464,7 @@ compileHLS targetHLS ghcs jobs ov installDir cabalProject cabalProjectLocal patc
                                    (if not shallow_clone then "\n  " <> "'git describe' output: " <> fromJust git_describe else mempty) <>
                                    (if isCommitHash ref then mempty else "\n  " <> "commit hash: " <> chash)

-        pure (tmpUnpack, tver, git_describe)
+        pure (tmpUnpack, tmpUnpack, tver, git_describe)

  -- the version that's installed may differ from the
  -- compiled version, so the user can overwrite it
@@ -441,7 +480,7 @@ compileHLS targetHLS ghcs jobs ov installDir cabalProject cabalProjectLocal patc
                  Right v -> pure v

  liftE $ runBuildAction
-    workdir
+    tmpUnpack
    (reThrowAll @_ @'[GPGError, DownloadFailed, DigestError, PatchFailed, ProcessError, FileAlreadyExistsError, CopyError] @'[BuildFailed] (BuildFailed $ fromGHCupPath workdir) $ do
      let tmpInstallDir = fromGHCupPath workdir </> "out"
      liftIO $ createDirRecursive' tmpInstallDir
@@ -457,14 +496,22 @@ compileHLS targetHLS ghcs jobs ov installDir cabalProject cabalProjectLocal patc
              pure "cabal.project"
          | otherwise -> pure (takeFileName cp)
        Just (Right uri) -> do
-          tmpUnpack <- lift withGHCupTmpDir
-          cp <- liftE $ download uri Nothing Nothing (fromGHCupPath tmpUnpack) (Just "cabal.project") False
+          tmpUnpack' <- lift withGHCupTmpDir
+          cp <- liftE $ download uri Nothing Nothing (fromGHCupPath tmpUnpack') (Just "cabal.project") False
          copyFileE cp (fromGHCupPath workdir </> "cabal.project") False
          pure "cabal.project"
-        Nothing -> pure "cabal.project"
+        Nothing
+          | HackageDist _ <- targetHLS -> do
+              liftIO $ B.writeFile (fromGHCupPath workdir </> "cabal.project") "packages: ./"
+              pure "cabal.project"
+          | RemoteDist _ <- targetHLS -> do
+              let cabalFile = fromGHCupPath workdir </> "cabal.project"
+              liftIO $ whenM (not <$> doesFileExist cabalFile) $ B.writeFile cabalFile "packages: ./"
+              pure "cabal.project"
+          | otherwise -> pure "cabal.project"
      forM_ cabalProjectLocal $ \uri -> do
-        tmpUnpack <- lift withGHCupTmpDir
-        cpl <- liftE $ download uri Nothing Nothing (fromGHCupPath tmpUnpack) (Just (cp <.> "local")) False
+        tmpUnpack' <- lift withGHCupTmpDir
+        cpl <- liftE $ download uri Nothing Nothing (fromGHCupPath tmpUnpack') (Just (cp <.> "local")) False
        copyFileE cpl (fromGHCupPath workdir </> cp <.> "local") False
      artifacts <- forM (sort ghcs) $ \ghc -> do
        let ghcInstallDir = tmpInstallDir </> T.unpack (prettyVer ghc)
@@ -658,3 +705,19 @@ rmHLSVer ver = do
    case headMay . reverse . sort $ hlsVers of
      Just latestver -> liftE $ setHLS latestver SetHLSOnly Nothing
      Nothing        -> pure ()
+
+
+getCabalVersion :: (MonadIO m, MonadFail m) => FilePath -> m Version
+getCabalVersion fp = do
+  contents <- liftIO $ B.readFile fp
+  gpd <- case parseGenericPackageDescriptionMaybe contents of
+           Nothing -> fail $ "could not parse cabal file: " <> fp
+           Just r -> pure r
+  let tver = (\c -> Version Nothing c [] Nothing)
+           . NE.fromList . fmap (NE.fromList . (:[]) . digits . fromIntegral)
+           . versionNumbers
+           . pkgVersion
+           . package
+           . packageDescription
+           $ gpd
+  pure tver
--- a/lib/GHCup/Prompts.hs
+++ b/lib/GHCup/Prompts.hs
@@ -0,0 +1,28 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE FlexibleContexts #-}
+
+module GHCup.Prompts
+  ( PromptQuestion,
+    PromptResponse (..),
+    getUserPromptResponse,
+  )
+where
+
+import Control.Monad.Reader
+import qualified Data.Text.IO as TIO
+import GHCup.Prelude.Logger
+import GHCup.Types.Optics
+import GHCup.Types (PromptQuestion, PromptResponse(..))
+
+getUserPromptResponse :: ( HasLog env
+                         , MonadReader env m
+                         , MonadIO m)
+                      => PromptQuestion
+                      -> m PromptResponse
+
+getUserPromptResponse prompt = do
+  logInfo prompt
+  resp <- liftIO TIO.getLine
+  if resp `elem` ["YES", "yes", "y", "Y"]
+    then pure PromptYes
+    else pure PromptNo
--- a/lib/GHCup/Types.hs
+++ b/lib/GHCup/Types.hs
@@ -657,10 +657,7 @@ isSafeDir (IsolateDirResolved _) = False
 isSafeDir (GHCupDir _)           = True
 isSafeDir (GHCupBinDir _)        = False

+type PromptQuestion = Text

-
-
-
-
-
-
+data PromptResponse = PromptYes | PromptNo
+  deriving (Show, Eq)
--- a/lib/GHCup/Utils.hs
+++ b/lib/GHCup/Utils.hs
@@ -1097,7 +1097,8 @@ runBuildAction bdir action = do

 -- | Clean up the given directory if the action fails,
 -- depending on the Settings.
-cleanUpOnError :: ( MonadReader env m
+cleanUpOnError :: forall e m a env .
+                  ( MonadReader env m
                  , HasDirs env
                  , HasSettings env
                  , MonadIO m
--- a/scripts/bootstrap/bootstrap-haskell
+++ b/scripts/bootstrap/bootstrap-haskell
@@ -140,8 +140,12 @@ ecabal() {
 }

 _ecabal() {
-    # shellcheck disable=SC2086
-    "${GHCUP_BIN}/cabal" "$@"
+    if [ -n "${CABAL_BIN}" ] ; then
+        "${CABAL_BIN}" "$@"
+    else
+        # shellcheck disable=SC2086
+        "${GHCUP_BIN}/cabal" "$@"
+    fi
 }

 _done() {
@@ -655,7 +659,7 @@ ask_hls() {
 		warn "Do you want to install haskell-language-server (HLS)?"
 		warn "HLS is a language-server that provides IDE-like functionality"
 		warn "and can integrate with different editors, such as Vim, Emacs, VS Code, Atom, ..."
-		warn "Also see https://github.com/haskell/haskell-language-server/blob/master/README.md"
+		warn "Also see https://haskell-language-server.readthedocs.io/en/stable/"
 		warn ""
 		warn "[Y] Yes  [N] No  [?] Help (default is \"N\")."
 		warn ""
@@ -817,7 +821,7 @@ else # don't install ghc and cabal
 				# we'll remove it afterwards
 				tmp_dir="$(mktemp -d)"
 				eghcup --cache install cabal -i "${tmp_dir}" "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
-				PATH="${tmp_dir}:$PATH" do_cabal_config_init $ask_cabal_config_init_answer
+				CABAL_BIN="${tmp_dir}/cabal" do_cabal_config_init $ask_cabal_config_init_answer
 				rm "${tmp_dir}/cabal"
 				unset tmp_dir
 				;;
Author	SHA1	Message	Date
Julian Ospald	3b6bb0df46	Add changelog	2022-07-29 21:52:56 +08:00
Julian Ospald	60299b6bb8	Update HLS doc link	2022-07-27 23:29:33 +08:00
Julian Ospald	4d20f4e07c	Merge branch 'issue-391'	2022-07-25 20:33:21 +08:00
Julian Ospald	5f6b5f845d	Add --disable-ld-override for darwin bindists Fixes #391	2022-07-25 17:57:10 +08:00
Julian Ospald	b0fecce0d1	Merge remote-tracking branch 'origin/merge-requests/273'	2022-07-24 20:24:00 +08:00
Mike Pilgrem	27c06ddde7	Fix #293 Document expressly how installation scripts can be customised The proposed addition does not go into the mechanism (the names of the specific environment variables or the PowerShell parameters) but is more express about in what manner the behaviour of the installation scripts can be changed. Introduces that important flexibility as the first topic under 'More on installation'. Explains that the PowerShell script finally (by default) runs the script for Unix-like operating systems (so a Windows user understands better that the environment variables in the former are applicable to both, and what is meant by the 'final' bootstrap script in the content of the Windows parameters). Refers to what has gone before, under 'Continuous integration', rather than repeat the added content.	2022-07-23 21:32:15 +01:00
Julian Ospald	3154d2839b	Merge remote-tracking branch 'origin/merge-requests/272'	2022-07-23 23:27:33 +08:00
Mike Pilgrem	511d8d5ed8	Update guide.md to explain what is meant by 'TUI'.	2022-07-23 14:25:49 +00:00
Julian Ospald	fe22405ee1	Merge branch 'issue-383'	2022-07-12 20:44:09 +02:00
Julian Ospald	ea828cd13a	Fix non-interactive install on windows	2022-07-12 20:26:57 +02:00
Julian Ospald	00fa70b9de	Merge remote-tracking branch 'origin/merge-requests/266'	2022-07-12 00:15:14 +02:00
Julian Ospald	823275363c	Merge branch 'ghcup-run-improvements'	2022-07-12 00:10:17 +02:00
Julian Ospald	2f299ee48d	Merge branch 'hls-hackage'	2022-07-12 00:06:40 +02:00
Julian Ospald	284fe1b3b6	Fix parser and completer for 'ghcup compile hls --version'	2022-07-12 00:05:08 +02:00
Julian Ospald	35bda8d67a	Fix hlint warnings	2022-07-11 19:49:08 +02:00
Julian Ospald	9673d28d3e	Docs	2022-07-11 00:40:39 +02:00
Julian Ospald	99a51d67a1	Make compiling from hackage the default	2022-07-10 21:58:03 +02:00
Arjun Kathuria	ca5c5550ab	removes newline after set' function	2022-07-10 21:49:54 +05:30
Arjun Kathuria	3d49f79beb	removes `prettyShow` from error case in BrickMain set'	2022-07-10 09:52:57 +05:30
Arjun Kathuria	e9740d13fc	Updates `userPrompt` in BrickMain to a more efficient version	2022-07-10 09:50:58 +05:30
Arjun Kathuria	2bd5a8fe1a	Removes redundant `putPrompt` function from Prompts module.	2022-07-10 09:45:39 +05:30
Arjun Kathuria	0acccae523	Removes `GHCup.Types.Prompts` module and stuffs it into `GHCup.Types`	2022-07-10 09:44:23 +05:30
Julian Ospald	974112016e	Allow to run 'cabal update' automatically before the HLS build	2022-07-09 23:50:20 +02:00
Julian Ospald	9fb2889696	Allow to build from arbitrary GHC source dists	2022-07-09 23:12:00 +02:00
Julian Ospald	63f22b28d7	Allow to build HLS from hackage	2022-07-09 21:12:23 +02:00
Arjun Kathuria	9ceb66ef21	chore: fix a hlint warning	2022-06-28 22:10:02 +05:30
Arjun Kathuria	7cbe38b011	Behavior Enhancement: make user press "S" only once to set, asks to install AND set if tool uninstalled	2022-06-28 19:50:22 +05:30
Arjun Kathuria	3bbc1edb19	updates user prompt message for "set" uninstalled version in BrickMain	2022-06-28 19:49:00 +05:30
Arjun Kathuria	b8dac2d7cd	Updates the Prompt module to use logInfo instead of putStrLn, makes the prompt look prettier	2022-06-28 19:45:17 +05:30
Arjun Kathuria	0e1fd68d93	when setting an uninstalled tool in tui, asks user to install first	2022-06-25 13:45:07 +05:30
Arjun Kathuria	c7eceb2330	Adds GHCup.Prompt modules and its types to project	2022-06-25 13:44:25 +05:30