{-# LANGUAGE MultiWayIf        #-}
{-# LANGUAGE NamedFieldPuns    #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards   #-}
module HaskellCI.GitHub (
    makeGitHub,
    githubHeader,
) where

import HaskellCI.Prelude

import Control.Applicative (optional)

import qualified Crypto.Hash.SHA256              as SHA256
import qualified Data.Attoparsec.Text            as Atto
import qualified Data.Binary                     as Binary
import qualified Data.Binary.Put                 as Binary
import qualified Data.ByteString.Base16          as Base16
import qualified Data.ByteString.Char8           as BS8
import qualified Data.Map.Strict                 as Map
import qualified Data.Set                        as S
import qualified Data.Text                       as T
import qualified Distribution.Fields.Pretty      as C
import qualified Distribution.Package            as C
import qualified Distribution.Pretty             as C
import qualified Distribution.Types.VersionRange as C
import qualified Distribution.Version            as C

import Cabal.Project
import HaskellCI.Auxiliary
import HaskellCI.Compiler
import HaskellCI.Config
import HaskellCI.Config.ConstraintSet
import HaskellCI.Config.Docspec
import HaskellCI.Config.Doctest
import HaskellCI.Config.HLint
import HaskellCI.Config.Installed
import HaskellCI.Config.Jobs
import HaskellCI.Config.PackageScope
import HaskellCI.Config.Ubuntu
import HaskellCI.Config.Validity
import HaskellCI.Cabal
import HaskellCI.GitConfig
import HaskellCI.GitHub.Yaml
import HaskellCI.HeadHackage
import HaskellCI.Jobs
import HaskellCI.List
import HaskellCI.MonadErr
import HaskellCI.Package
import HaskellCI.Sh
import HaskellCI.ShVersionRange
import HaskellCI.Tools
import HaskellCI.VersionInfo

-- $setup
-- >>> :set -XOverloadedStrings

-------------------------------------------------------------------------------
-- GitHub header
-------------------------------------------------------------------------------

githubHeader :: Bool -> [String] -> [String]
githubHeader :: Bool -> [[Char]] -> [[Char]]
githubHeader Bool
insertVersion [[Char]]
argv =
    [ [Char]
"This GitHub workflow config has been generated by a script via"
    , [Char]
""
    , [Char]
"  haskell-ci " forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
unwords [ [Char]
"'" forall a. [a] -> [a] -> [a]
++ [Char]
a forall a. [a] -> [a] -> [a]
++ [Char]
"'" | [Char]
a <- [[Char]]
argv ]
    , [Char]
""
    , [Char]
"To regenerate the script (for example after adjusting tested-with) run"
    , [Char]
""
    , [Char]
"  haskell-ci regenerate"
    , [Char]
""
    , [Char]
"For more information, see https://github.com/haskell-CI/haskell-ci"
    , [Char]
""
    ] forall a. [a] -> [a] -> [a]
++
    [[Char]]
verlines forall a. [a] -> [a] -> [a]
++
    [ [Char]
"REGENDATA " forall a. [a] -> [a] -> [a]
++ if Bool
insertVersion then forall a. Show a => a -> [Char]
show ([Char]
haskellCIVerStr, [[Char]]
argv) else forall a. Show a => a -> [Char]
show [[Char]]
argv
    , [Char]
""
    ]
  where
    verlines :: [[Char]]
verlines
        | Bool
insertVersion = [ [Char]
"version: " forall a. [a] -> [a] -> [a]
++ [Char]
haskellCIVerStr , [Char]
"" ]
        | Bool
otherwise     = []

-------------------------------------------------------------------------------
-- GitHub
-------------------------------------------------------------------------------

{-
GitHub Actions–specific notes:

* We use -j2 for parallelism, as GitHub's virtual machines use 2 cores, per
  https://docs.github.com/en/free-pro-team@latest/actions/reference/specifications-for-github-hosted-runners#supported-runners-and-hardware-resources.
-}

makeGitHub
    :: [String]
    -> Config
    -> GitConfig
    -> Project URI Void Package
    -> JobVersions
    -> Either HsCiError GitHub
makeGitHub :: [[Char]]
-> Config
-> GitConfig
-> Project URI Void Package
-> JobVersions
-> Either HsCiError GitHub
makeGitHub [[Char]]
_argv config :: Config
config@Config {Bool
Natural
[Char]
[[Char]]
[PackageName]
[PrettyField ()]
[Installed]
[ConstraintSet]
Maybe [Char]
Maybe Version
Maybe Jobs
VersionRange
Version
Set [Char]
Set Fold
Map Version [Char]
Ubuntu
PackageScope
HLintConfig
DoctestConfig
DocspecConfig
CopyFields
Components
TestedWithJobs
cfgTimeoutMinutes :: Config -> Natural
cfgGitHubActionName :: Config -> Maybe [Char]
cfgRawTravis :: Config -> [Char]
cfgRawProject :: Config -> [PrettyField ()]
cfgConstraintSets :: Config -> [ConstraintSet]
cfgHLint :: Config -> HLintConfig
cfgDocspec :: Config -> DocspecConfig
cfgDoctest :: Config -> DoctestConfig
cfgErrorMissingMethods :: Config -> PackageScope
cfgInsertVersion :: Config -> Bool
cfgGitHubPatches :: Config -> [[Char]]
cfgTravisPatches :: Config -> [[Char]]
cfgApt :: Config -> Set [Char]
cfgGhcupVersion :: Config -> Version
cfgGhcupJobs :: Config -> VersionRange
cfgGhcupCabal :: Config -> Bool
cfgMacosJobs :: Config -> VersionRange
cfgLinuxJobs :: Config -> VersionRange
cfgLastInSeries :: Config -> Bool
cfgAllowFailures :: Config -> VersionRange
cfgEnv :: Config -> Map Version [Char]
cfgGoogleChrome :: Config -> Bool
cfgPostgres :: Config -> Bool
cfgGhcHead :: Config -> Bool
cfgFolds :: Config -> Set Fold
cfgProjectName :: Config -> Maybe [Char]
cfgEmailNotifications :: Config -> Bool
cfgIrcIfInOriginRepo :: Config -> Bool
cfgIrcPassword :: Config -> Maybe [Char]
cfgIrcNickname :: Config -> Maybe [Char]
cfgIrcChannels :: Config -> [[Char]]
cfgOnlyBranches :: Config -> [[Char]]
cfgCheck :: Config -> Bool
cfgTestOutputDirect :: Config -> Bool
cfgGhcjsTools :: Config -> [PackageName]
cfgGhcjsTests :: Config -> Bool
cfgHeadHackageOverride :: Config -> Bool
cfgHeadHackage :: Config -> VersionRange
cfgUnconstrainted :: Config -> VersionRange
cfgNoTestsNoBench :: Config -> VersionRange
cfgHaddockComponents :: Config -> Components
cfgHaddock :: Config -> VersionRange
cfgBenchmarks :: Config -> VersionRange
cfgRunTests :: Config -> VersionRange
cfgTests :: Config -> VersionRange
cfgInstalled :: Config -> [Installed]
cfgInstallDeps :: Config -> Bool
cfgCache :: Config -> Bool
cfgSubmodules :: Config -> Bool
cfgLocalGhcOptions :: Config -> [[Char]]
cfgCopyFields :: Config -> CopyFields
cfgEnabledJobs :: Config -> VersionRange
cfgTestedWith :: Config -> TestedWithJobs
cfgUbuntu :: Config -> Ubuntu
cfgJobs :: Config -> Maybe Jobs
cfgCabalInstallVersion :: Config -> Maybe Version
cfgTimeoutMinutes :: Natural
cfgGitHubActionName :: Maybe [Char]
cfgRawTravis :: [Char]
cfgRawProject :: [PrettyField ()]
cfgConstraintSets :: [ConstraintSet]
cfgHLint :: HLintConfig
cfgDocspec :: DocspecConfig
cfgDoctest :: DoctestConfig
cfgErrorMissingMethods :: PackageScope
cfgInsertVersion :: Bool
cfgGitHubPatches :: [[Char]]
cfgTravisPatches :: [[Char]]
cfgApt :: Set [Char]
cfgGhcupVersion :: Version
cfgGhcupJobs :: VersionRange
cfgGhcupCabal :: Bool
cfgMacosJobs :: VersionRange
cfgLinuxJobs :: VersionRange
cfgLastInSeries :: Bool
cfgAllowFailures :: VersionRange
cfgEnv :: Map Version [Char]
cfgGoogleChrome :: Bool
cfgPostgres :: Bool
cfgGhcHead :: Bool
cfgFolds :: Set Fold
cfgProjectName :: Maybe [Char]
cfgEmailNotifications :: Bool
cfgIrcIfInOriginRepo :: Bool
cfgIrcPassword :: Maybe [Char]
cfgIrcNickname :: Maybe [Char]
cfgIrcChannels :: [[Char]]
cfgOnlyBranches :: [[Char]]
cfgCheck :: Bool
cfgTestOutputDirect :: Bool
cfgGhcjsTools :: [PackageName]
cfgGhcjsTests :: Bool
cfgHeadHackageOverride :: Bool
cfgHeadHackage :: VersionRange
cfgUnconstrainted :: VersionRange
cfgNoTestsNoBench :: VersionRange
cfgHaddockComponents :: Components
cfgHaddock :: VersionRange
cfgBenchmarks :: VersionRange
cfgRunTests :: VersionRange
cfgTests :: VersionRange
cfgInstalled :: [Installed]
cfgInstallDeps :: Bool
cfgCache :: Bool
cfgSubmodules :: Bool
cfgLocalGhcOptions :: [[Char]]
cfgCopyFields :: CopyFields
cfgEnabledJobs :: VersionRange
cfgTestedWith :: TestedWithJobs
cfgUbuntu :: Ubuntu
cfgJobs :: Maybe Jobs
cfgCabalInstallVersion :: Maybe Version
..} GitConfig
gitconfig Project URI Void Package
prj jobs :: JobVersions
jobs@JobVersions {Set CompilerVersion
macosVersions :: JobVersions -> Set CompilerVersion
linuxVersions :: JobVersions -> Set CompilerVersion
allVersions :: JobVersions -> Set CompilerVersion
macosVersions :: Set CompilerVersion
linuxVersions :: Set CompilerVersion
allVersions :: Set CompilerVersion
..} = do
    let envEnv :: Map [Char] [Char]
envEnv = forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
            [ ([Char]
"HCNAME", [Char]
"${{ matrix.compiler }}")         -- e.g. ghc-8.8.4
            , ([Char]
"HCKIND", [Char]
"${{ matrix.compilerKind }}")     --      ghc
            , ([Char]
"HCVER",  [Char]
"${{ matrix.compilerVersion }}")  --      8.8.4
            ]

    -- Validity checks
    forall (m :: * -> *).
MonadErr HsCiError m =>
Config -> JobVersions -> m ()
checkConfigValidity Config
config JobVersions
jobs
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
cfgSubmodules Bool -> Bool -> Bool
&& Ubuntu
cfgUbuntu forall a. Ord a => a -> a -> Bool
< Ubuntu
Focal) forall a b. (a -> b) -> a -> b
$
        forall e (m :: * -> *) a. MonadErr e m => e -> m a
throwErr forall a b. (a -> b) -> a -> b
$ [Char] -> HsCiError
ValidationError forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unwords
            [ [Char]
"Using submodules on the GitHub Actions backend requires"
            , [Char]
"Ubuntu 20.04 (Focal Fossa) or later."
            ]

    [GitHubStep]
steps <- forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence forall a b. (a -> b) -> a -> b
$ forall x. ListBuilder x () -> [x]
buildList forall a b. (a -> b) -> a -> b
$ do
        -- This have to be first, since the packages we install depend on
        -- whether we need GHCJS or not.
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
anyGHCJS forall a b. (a -> b) -> a -> b
$ [Char]
-> Map [Char] [Char]
-> ShM ()
-> ListBuilder (Either HsCiError GitHubStep) ()
githubRun' [Char]
"Set GHCJS environment variables" Map [Char] [Char]
envEnv forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [[a]] -> [a]
intercalate [Char]
"\n"
            [ [Char]
"if [ $HCKIND = ghcjs ]; then"
            , [Char] -> [Char] -> [Char]
tell_env' [Char]
"GHCJS" [Char]
"true"
            , [Char] -> [Char] -> [Char]
tell_env' [Char]
"GHCJSARITH" [Char]
"1"
            , [Char]
"else"
            , [Char] -> [Char] -> [Char]
tell_env' [Char]
"GHCJS" [Char]
"false"
            , [Char] -> [Char] -> [Char]
tell_env' [Char]
"GHCJSARITH" [Char]
"0"
            , [Char]
"fi"
            ]

        [Char]
-> Map [Char] [Char]
-> ShM ()
-> ListBuilder (Either HsCiError GitHubStep) ()
githubRun' [Char]
"apt" Map [Char] [Char]
envEnv forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"apt-get update"
            let corePkgs :: [String]
                corePkgs :: [[Char]]
corePkgs =
                    [ [Char]
"gnupg"
                    , [Char]
"ca-certificates"
                    , [Char]
"dirmngr"
                    , [Char]
"curl"
                    , [Char]
"git"
                    , [Char]
"software-properties-common"
                    , [Char]
"libtinfo5"
                    ] forall a. [a] -> [a] -> [a]
++
                    -- Installing libnuma-dev is required to work around
                    -- https://gitlab.haskell.org/haskell/ghcup-hs/-/blob/b0522507be6fa991a819aaf22f9a551757380821/README.md#libnuma-required
                    [ [Char]
"libnuma-dev"
                    | Version -> CompilerVersion
GHC ([Int] -> Version
C.mkVersion [Int
8,Int
4,Int
4]) forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` Set CompilerVersion
allVersions
                    , Version -> CompilerVersion
GHC ([Int] -> Version
C.mkVersion [Int
8,Int
4,Int
4]) forall a b. a -> (a -> b) -> b
& CompilerVersion -> Bool
isGHCUP
                    ]
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char]
"apt-get install -y --no-install-recommends " forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
unwords [[Char]]
corePkgs

            let installGhcup :: ShM ()
                installGhcup :: ShM ()
installGhcup = do
                    let ghcupVer :: [Char]
ghcupVer = forall a. Pretty a => a -> [Char]
C.prettyShow Version
cfgGhcupVersion
                    forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char]
"mkdir -p \"$HOME/.ghcup/bin\""
                    forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char]
"curl -sL https://downloads.haskell.org/ghcup/" forall a. [a] -> [a] -> [a]
++ [Char]
ghcupVer forall a. [a] -> [a] -> [a]
++ [Char]
"/x86_64-linux-ghcup-" forall a. [a] -> [a] -> [a]
++ [Char]
ghcupVer forall a. [a] -> [a] -> [a]
++ [Char]
" > \"$HOME/.ghcup/bin/ghcup\""
                    forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char]
"chmod a+x \"$HOME/.ghcup/bin/ghcup\""

                    -- if any job uses prereleases, add release channel unconditionally. (HEADHACKAGE variable is set later)
                    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
anyJobUsesHeadHackage Bool -> Bool -> Bool
|| Maybe Version -> Bool
previewCabal Maybe Version
cfgCabalInstallVersion) forall a b. (a -> b) -> a -> b
$
                      forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"\"$HOME/.ghcup/bin/ghcup\" config add-release-channel https://raw.githubusercontent.com/haskell/ghcup-metadata/master/ghcup-prereleases-0.0.7.yaml;"

                installGhcupCabal :: ShM ()
                installGhcupCabal :: ShM ()
installGhcupCabal =
                    forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char]
"\"$HOME/.ghcup/bin/ghcup\" install cabal " forall a. [a] -> [a] -> [a]
++ [Char]
cabalFullVer forall a. [a] -> [a] -> [a]
++ [Char]
" || (cat \"$HOME\"/.ghcup/logs/*.* && false)"

            [Sh]
hvrppa <- forall e (m :: * -> *).
(MonadErr e m, FromHsCiError e) =>
ShM () -> m [Sh]
runSh forall a b. (a -> b) -> a -> b
$ do
                forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"apt-add-repository -y 'ppa:hvr/ghc'"
                forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
anyGHCJS forall a b. (a -> b) -> a -> b
$ do
                    CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
RangeGHCJS [Char]
"apt-add-repository -y 'ppa:hvr/ghcjs'"
                    CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
RangeGHCJS [Char]
"curl -sSL \"https://deb.nodesource.com/gpgkey/nodesource.gpg.key\" | apt-key add -"
                    CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
RangeGHCJS forall a b. (a -> b) -> a -> b
$ [Char]
"apt-add-repository -y 'deb https://deb.nodesource.com/node_10.x " forall a. [a] -> [a] -> [a]
++ [Char]
ubuntuVer forall a. [a] -> [a] -> [a]
++ [Char]
" main'"
                forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"apt-get update"
                let basePackages :: [[Char]]
basePackages  = [[Char]
"\"$HCNAME\"" ] forall a. [a] -> [a] -> [a]
++ [ [Char]
"cabal-install-" forall a. [a] -> [a] -> [a]
++ [Char]
cabalVer | Bool -> Bool
not Bool
cfgGhcupCabal ] forall a. [a] -> [a] -> [a]
++ forall a. Set a -> [a]
S.toList Set [Char]
cfgApt
                    ghcjsPackages :: [[Char]]
ghcjsPackages = [[Char]
"ghc-8.4.4", [Char]
"nodejs"]
                    baseInstall :: [Char]
baseInstall   = [Char]
"apt-get install -y " forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
unwords [[Char]]
basePackages
                    ghcjsInstall :: [Char]
ghcjsInstall  = [Char]
"apt-get install -y " forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
unwords ([[Char]]
basePackages forall a. [a] -> [a] -> [a]
++ [[Char]]
ghcjsPackages)
                if Bool
anyGHCJS
                    then CompilerRange -> [Char] -> [Char] -> ShM ()
if_then_else CompilerRange
RangeGHCJS [Char]
ghcjsInstall [Char]
baseInstall
                    else forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
baseInstall
                forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
cfgGhcupCabal forall a b. (a -> b) -> a -> b
$ do
                    ShM ()
installGhcup
                    ShM ()
installGhcupCabal

            [Sh]
ghcup <- forall e (m :: * -> *).
(MonadErr e m, FromHsCiError e) =>
ShM () -> m [Sh]
runSh forall a b. (a -> b) -> a -> b
$ do
                ShM ()
installGhcup

                forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char]
"\"$HOME/.ghcup/bin/ghcup\" install ghc \"$HCVER\" || (cat \"$HOME\"/.ghcup/logs/*.* && false)"
                ShM ()
installGhcupCabal
                forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
null Set [Char]
cfgApt) forall a b. (a -> b) -> a -> b
$ do
                    forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"apt-get update"
                    forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char]
"apt-get install -y " forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
unwords (forall a. Set a -> [a]
S.toList Set [Char]
cfgApt)

            [Sh] -> [Sh] -> ShM ()
setup [Sh]
hvrppa [Sh]
ghcup

        [Char]
-> Map [Char] [Char]
-> ShM ()
-> ListBuilder (Either HsCiError GitHubStep) ()
githubRun' [Char]
"Set PATH and environment variables" Map [Char] [Char]
envEnv forall a b. (a -> b) -> a -> b
$ do
            [Char] -> [Char] -> ShM ()
echo_to [Char]
"$GITHUB_PATH" [Char]
"$HOME/.cabal/bin"

            -- Hack: happy needs ghc. Let's install version matching GHCJS.
            -- At the moment, there is only GHCJS-8.4, so we install GHC-8.4.4
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
anyGHCJS forall a b. (a -> b) -> a -> b
$
                CompilerRange -> [Char] -> [Char] -> ShM ()
echo_if_to CompilerRange
RangeGHCJS [Char]
"$GITHUB_PATH" [Char]
"/opt/ghc/8.4.4/bin"

            [Char] -> [Char] -> ShM ()
tell_env [Char]
"LANG" [Char]
"C.UTF-8"

            [Char] -> [Char] -> ShM ()
tell_env [Char]
"CABAL_DIR"    [Char]
"$HOME/.cabal"
            [Char] -> [Char] -> ShM ()
tell_env [Char]
"CABAL_CONFIG" [Char]
"$HOME/.cabal/config"

            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"HCDIR=/opt/$HCKIND/$HCVER"

            let ghcupCabalPath :: ShM ()
ghcupCabalPath = [Char] -> [Char] -> ShM ()
tell_env [Char]
"CABAL" forall a b. (a -> b) -> a -> b
$ [Char]
"$HOME/.ghcup/bin/cabal-" forall a. [a] -> [a] -> [a]
++ [Char]
cabalFullVer forall a. [a] -> [a] -> [a]
++ [Char]
" -vnormal+nowrap"

            [Sh]
hvrppa <- forall e (m :: * -> *).
(MonadErr e m, FromHsCiError e) =>
ShM () -> m [Sh]
runSh forall a b. (a -> b) -> a -> b
$ do
                let hc :: [Char]
hc = [Char]
"$HCDIR/bin/$HCKIND"
                forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char]
"HC=" forall a. [a] -> [a] -> [a]
++ [Char]
hc -- HC is an absolute path.
                [Char] -> [Char] -> ShM ()
tell_env [Char]
"HC" [Char]
"$HC"
                [Char] -> [Char] -> ShM ()
tell_env [Char]
"HCPKG" forall a b. (a -> b) -> a -> b
$ [Char]
hc forall a. [a] -> [a] -> [a]
++ [Char]
"-pkg"
                [Char] -> [Char] -> ShM ()
tell_env [Char]
"HADDOCK" [Char]
"$HCDIR/bin/haddock"
                if Bool
cfgGhcupCabal
                then ShM ()
ghcupCabalPath
                else [Char] -> [Char] -> ShM ()
tell_env [Char]
"CABAL" forall a b. (a -> b) -> a -> b
$ [Char]
"/opt/cabal/" forall a. [a] -> [a] -> [a]
++ [Char]
cabalVer forall a. [a] -> [a] -> [a]
++ [Char]
"/bin/cabal -vnormal+nowrap"

            [Sh]
ghcup <- forall e (m :: * -> *).
(MonadErr e m, FromHsCiError e) =>
ShM () -> m [Sh]
runSh forall a b. (a -> b) -> a -> b
$ do
                let hc :: [Char]
hc = [Char]
"$HOME/.ghcup/bin/$HCKIND-$HCVER"
                forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char]
"HC=" forall a. [a] -> [a] -> [a]
++ [Char]
hc -- HC is an absolute path.
                [Char] -> [Char] -> ShM ()
tell_env [Char]
"HC"      [Char]
"$HC"
                [Char] -> [Char] -> ShM ()
tell_env [Char]
"HCPKG" forall a b. (a -> b) -> a -> b
$ [Char]
"$HOME/.ghcup/bin/$HCKIND-pkg-$HCVER"
                [Char] -> [Char] -> ShM ()
tell_env [Char]
"HADDOCK" [Char]
"$HOME/.ghcup/bin/haddock-$HCVER"
                ShM ()
ghcupCabalPath

            [Sh] -> [Sh] -> ShM ()
setup [Sh]
hvrppa [Sh]
ghcup

            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"HCNUMVER=$(${HC} --numeric-version|perl -ne '/^(\\d+)\\.(\\d+)\\.(\\d+)(\\.(\\d+))?$/; print(10000 * $1 + 100 * $2 + ($3 == 0 ? $5 != 1 : $3))')"
            [Char] -> [Char] -> ShM ()
tell_env [Char]
"HCNUMVER" [Char]
"$HCNUMVER"

            CompilerRange -> [Char] -> [Char] -> ShM ()
if_then_else (VersionRange -> CompilerRange
Range VersionRange
cfgTests)
                ([Char] -> [Char] -> [Char]
tell_env' [Char]
"ARG_TESTS" [Char]
"--enable-tests")
                ([Char] -> [Char] -> [Char]
tell_env' [Char]
"ARG_TESTS" [Char]
"--disable-tests")
            CompilerRange -> [Char] -> [Char] -> ShM ()
if_then_else (VersionRange -> CompilerRange
Range VersionRange
cfgBenchmarks)
                ([Char] -> [Char] -> [Char]
tell_env' [Char]
"ARG_BENCH" [Char]
"--enable-benchmarks")
                ([Char] -> [Char] -> [Char]
tell_env' [Char]
"ARG_BENCH" [Char]
"--disable-benchmarks")
            CompilerRange -> [Char] -> [Char] -> ShM ()
if_then_else (VersionRange -> CompilerRange
Range VersionRange
cfgHeadHackage forall a. Lattice a => a -> a -> a
\/ Set CompilerVersion -> CompilerRange
RangePoints (forall a. a -> Set a
S.singleton CompilerVersion
GHCHead))
                ([Char] -> [Char] -> [Char]
tell_env' [Char]
"HEADHACKAGE" [Char]
"true")
                ([Char] -> [Char] -> [Char]
tell_env' [Char]
"HEADHACKAGE" [Char]
"false")

            [Char] -> [Char] -> ShM ()
tell_env [Char]
"ARG_COMPILER" [Char]
"--$HCKIND --with-compiler=$HC"

            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
anyGHCJS forall a b. (a -> b) -> a -> b
$
                [Char] -> [Char] -> ShM ()
tell_env [Char]
"GHCJSARITH" [Char]
"0"

        [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"env" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"env"

        [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"write cabal config" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"mkdir -p $CABAL_DIR"
            [Char] -> [Char] -> ShM ()
cat [Char]
"$CABAL_CONFIG" forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unlines
                [ [Char]
"remote-build-reporting: anonymous"
                , [Char]
"write-ghc-environment-files: never"
                , [Char]
"remote-repo-cache: $CABAL_DIR/packages"
                , [Char]
"logs-dir:          $CABAL_DIR/logs"
                , [Char]
"world-file:        $CABAL_DIR/world"
                , [Char]
"extra-prog-path:   $CABAL_DIR/bin"
                , [Char]
"symlink-bindir:    $CABAL_DIR/bin"
                , [Char]
"installdir:        $CABAL_DIR/bin"
                , [Char]
"build-summary:     $CABAL_DIR/logs/build.log"
                , [Char]
"store-dir:         $CABAL_DIR/store"
                , [Char]
"install-dirs user"
                , [Char]
"  prefix: $CABAL_DIR"
                , [Char]
"repository hackage.haskell.org"
                , [Char]
"  url: http://hackage.haskell.org/"
                ]

            -- Add head.hackage repository to ~/.cabal/config
            -- (locally you want to add it to cabal.project)
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
anyJobUsesHeadHackage forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall a b. (a -> b) -> a -> b
$
                [ [Char]
"if $HEADHACKAGE; then\n"
                , [Char] -> [Char] -> [Char]
catCmd [Char]
"$CABAL_CONFIG" forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unlines forall a b. (a -> b) -> a -> b
$ Bool -> [[Char]]
headHackageRepoStanza Bool
cfgHeadHackageOverride
                , [Char]
"\nfi"
                ]

            -- Cabal jobs
            forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (Maybe Jobs
cfgJobs forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Jobs -> Maybe Int
cabalJobs) forall a b. (a -> b) -> a -> b
$ \Int
n ->
                [Char] -> [Char] -> ShM ()
cat [Char]
"$CABAL_CONFIG" forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unlines
                    [ [Char]
"jobs: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Int
n
                    ]

            -- GHC jobs + ghc-options
            forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (Maybe Jobs
cfgJobs forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Jobs -> Maybe Int
ghcJobs) forall a b. (a -> b) -> a -> b
$ \Int
m -> do
                CompilerRange -> [Char] -> ShM ()
sh_if (VersionRange -> CompilerRange
Range forall a b. (a -> b) -> a -> b
$ Version -> VersionRange
C.orLaterVersion ([Int] -> Version
C.mkVersion [Int
7,Int
8])) forall a b. (a -> b) -> a -> b
$ [Char]
"GHCJOBS=-j" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Int
m

            [Char] -> [Char] -> ShM ()
cat [Char]
"$CABAL_CONFIG" forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unlines
                [ [Char]
"program-default-options"
                , [Char]
"  ghc-options: $GHCJOBS +RTS -M3G -RTS"
                ]

            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"cat $CABAL_CONFIG"

        [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"versions" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"$HC --version || true"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"$HC --print-project-git-commit-id || true"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"$CABAL --version || true"
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
anyGHCJS forall a b. (a -> b) -> a -> b
$ do
                CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
RangeGHCJS [Char]
"node --version"
                CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
RangeGHCJS [Char]
"echo $GHCJS"

        [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"update cabal index" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"$CABAL v2-update -v"

        let toolsConfigHash :: String
            toolsConfigHash :: [Char]
toolsConfigHash = forall a. Int -> [a] -> [a]
take Int
8 forall a b. (a -> b) -> a -> b
$ ByteString -> [Char]
BS8.unpack forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString
Base16.encode forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString
SHA256.hashlazy forall a b. (a -> b) -> a -> b
$ Put -> ByteString
Binary.runPut forall a b. (a -> b) -> a -> b
$ do
                forall t. Binary t => t -> Put
Binary.put DoctestConfig
cfgDoctest
                forall t. Binary t => t -> Put
Binary.put HLintConfig
cfgHLint
                forall t. Binary t => t -> Put
Binary.put VersionRange
cfgGhcupJobs -- GHC location affects doctest, e.g

        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
doctestEnabled Bool -> Bool -> Bool
|| HLintConfig -> Bool
cfgHLintEnabled HLintConfig
cfgHLint) forall a b. (a -> b) -> a -> b
$ [Char]
-> [Char]
-> [([Char], [Char])]
-> ListBuilder (Either HsCiError GitHubStep) ()
githubUses [Char]
"cache (tools)" [Char]
"actions/cache/restore@v3"
            [ ([Char]
"key", [Char]
"${{ runner.os }}-${{ matrix.compiler }}-tools-" forall a. [a] -> [a] -> [a]
++ [Char]
toolsConfigHash)
            , ([Char]
"path", [Char]
"~/.haskell-ci-tools")
            ]

        [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"install cabal-plan" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"mkdir -p $HOME/.cabal/bin"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"curl -sL https://github.com/haskell-hvr/cabal-plan/releases/download/v0.7.3.0/cabal-plan-0.7.3.0-x86_64-linux.xz > cabal-plan.xz"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"echo 'f62ccb2971567a5f638f2005ad3173dba14693a45154c1508645c52289714cb2  cabal-plan.xz' | sha256sum -c -"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"xz -d < cabal-plan.xz > $HOME/.cabal/bin/cabal-plan"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"rm -f cabal-plan.xz"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"chmod a+x $HOME/.cabal/bin/cabal-plan"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"cabal-plan --version"

        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
anyGHCJS forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"install happy" forall a b. (a -> b) -> a -> b
$ do
            forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [PackageName]
cfgGhcjsTools forall a b. (a -> b) -> a -> b
$ \PackageName
t ->
                CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
RangeGHCJS forall a b. (a -> b) -> a -> b
$ [Char]
"$CABAL v2-install -w ghc-8.4.4 --ignore-project -j2" forall a. [a] -> [a] -> [a]
++ forall a. Pretty a => a -> [Char]
C.prettyShow PackageName
t

        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
docspecEnabled forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"install cabal-docspec" forall a b. (a -> b) -> a -> b
$ do
            let hash :: [Char]
hash = DocspecConfig -> [Char]
cfgDocspecHash DocspecConfig
cfgDocspec
                url :: [Char]
url  = DocspecConfig -> [Char]
cfgDocspecUrl DocspecConfig
cfgDocspec
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"mkdir -p $HOME/.cabal/bin"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char]
"curl -sL " forall a. [a] -> [a] -> [a]
++ [Char]
url forall a. [a] -> [a] -> [a]
++ [Char]
" > cabal-docspec.xz"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char]
"echo '" forall a. [a] -> [a] -> [a]
++ [Char]
hash forall a. [a] -> [a] -> [a]
++ [Char]
"  cabal-docspec.xz' | sha256sum -c -"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"xz -d < cabal-docspec.xz > $HOME/.cabal/bin/cabal-docspec"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"rm -f cabal-docspec.xz"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"chmod a+x $HOME/.cabal/bin/cabal-docspec"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"cabal-docspec --version"

        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
doctestEnabled forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"install doctest" forall a b. (a -> b) -> a -> b
$ do
            let range :: CompilerRange
range = VersionRange -> CompilerRange
Range (DoctestConfig -> VersionRange
cfgDoctestEnabled DoctestConfig
cfgDoctest) forall a. Lattice a => a -> a -> a
/\ CompilerRange
doctestJobVersionRange
            CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
range [Char]
"$CABAL --store-dir=$HOME/.haskell-ci-tools/store v2-install $ARG_COMPILER --ignore-project -j2 doctest --constraint='doctest ^>=0.20'"
            CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
range [Char]
"doctest --version"

        let hlintVersionConstraint :: [Char]
hlintVersionConstraint
                | VersionRange -> Bool
C.isAnyVersion (HLintConfig -> VersionRange
cfgHLintVersion HLintConfig
cfgHLint) = [Char]
""
                | Bool
otherwise = [Char]
" --constraint='hlint " forall a. [a] -> [a] -> [a]
++ forall a. Pretty a => a -> [Char]
prettyShow (HLintConfig -> VersionRange
cfgHLintVersion HLintConfig
cfgHLint) forall a. [a] -> [a] -> [a]
++ [Char]
"'"
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (HLintConfig -> Bool
cfgHLintEnabled HLintConfig
cfgHLint) forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"install hlint" forall a b. (a -> b) -> a -> b
$ do
            let forHLint :: [Char] -> ShM ()
forHLint = CompilerRange -> [Char] -> ShM ()
sh_if (Set CompilerVersion -> VersionRange -> HLintJob -> CompilerRange
hlintJobVersionRange Set CompilerVersion
allVersions VersionRange
cfgHeadHackage (HLintConfig -> HLintJob
cfgHLintJob HLintConfig
cfgHLint))
            if HLintConfig -> Bool
cfgHLintDownload HLintConfig
cfgHLint
            then do
                -- install --dry-run and use perl regex magic to find a hlint version
                -- -v is important
                [Char] -> ShM ()
forHLint forall a b. (a -> b) -> a -> b
$ [Char]
"HLINTVER=$(cd /tmp && (${CABAL} v2-install -v $ARG_COMPILER --dry-run hlint " forall a. [a] -> [a] -> [a]
++ [Char]
hlintVersionConstraint forall a. [a] -> [a] -> [a]
++ [Char]
" |  perl -ne 'if (/\\bhlint-(\\d+(\\.\\d+)*)\\b/) { print \"$1\"; last; }')); echo \"HLint version $HLINTVER\""
                [Char] -> ShM ()
forHLint forall a b. (a -> b) -> a -> b
$ [Char]
"if [ ! -e $HOME/.haskell-ci-tools/hlint-$HLINTVER/hlint ]; then " forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
unwords
                    [ [Char]
"echo \"Downloading HLint version $HLINTVER\";"
                    , [Char]
"mkdir -p $HOME/.haskell-ci-tools;"
                    , [Char]
"curl --write-out 'Status Code: %{http_code} Redirects: %{num_redirects} Total time: %{time_total} Total Dsize: %{size_download}\\n' --silent --location --output $HOME/.haskell-ci-tools/hlint-$HLINTVER.tar.gz \"https://github.com/ndmitchell/hlint/releases/download/v$HLINTVER/hlint-$HLINTVER-x86_64-linux.tar.gz\";"
                    , [Char]
"tar -xzv -f $HOME/.haskell-ci-tools/hlint-$HLINTVER.tar.gz -C $HOME/.haskell-ci-tools;"
                    , [Char]
"fi"
                    ]
                [Char] -> ShM ()
forHLint [Char]
"mkdir -p $CABAL_DIR/bin && ln -sf \"$HOME/.haskell-ci-tools/hlint-$HLINTVER/hlint\" $CABAL_DIR/bin/hlint"
                [Char] -> ShM ()
forHLint [Char]
"hlint --version"

            else do
                [Char] -> ShM ()
forHLint forall a b. (a -> b) -> a -> b
$ [Char]
"$CABAL --store-dir=$HOME/.haskell-ci-tools/store v2-install $ARG_COMPILER --ignore-project -j2 hlint" forall a. [a] -> [a] -> [a]
++ [Char]
hlintVersionConstraint
                [Char] -> ShM ()
forHLint [Char]
"hlint --version"

        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
doctestEnabled Bool -> Bool -> Bool
|| HLintConfig -> Bool
cfgHLintEnabled HLintConfig
cfgHLint) forall a b. (a -> b) -> a -> b
$ [Char]
-> [Char]
-> [Char]
-> [([Char], [Char])]
-> ListBuilder (Either HsCiError GitHubStep) ()
githubUsesIf [Char]
"save cache (tools)" [Char]
"actions/cache/save@v3" [Char]
"always()"
            [ ([Char]
"key", [Char]
"${{ runner.os }}-${{ matrix.compiler }}-tools-" forall a. [a] -> [a] -> [a]
++ [Char]
toolsConfigHash)
            , ([Char]
"path", [Char]
"~/.haskell-ci-tools")
            ]

        [Char]
-> [Char]
-> [([Char], [Char])]
-> ListBuilder (Either HsCiError GitHubStep) ()
githubUses [Char]
"checkout" [Char]
"actions/checkout@v3" forall a b. (a -> b) -> a -> b
$ forall x. ListBuilder x () -> [x]
buildList forall a b. (a -> b) -> a -> b
$ do
            forall x. x -> ListBuilder x ()
item ([Char]
"path", [Char]
"source")
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
cfgSubmodules forall a b. (a -> b) -> a -> b
$
                forall x. x -> ListBuilder x ()
item ([Char]
"submodules", [Char]
"true")

        [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"initial cabal.project for sdist" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"touch cabal.project"
            forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Package]
pkgs forall a b. (a -> b) -> a -> b
$ \Package
pkg ->
                CompilerRange -> [Char] -> [Char] -> ShM ()
echo_if_to (Set CompilerVersion -> CompilerRange
RangePoints forall a b. (a -> b) -> a -> b
$ Package -> Set CompilerVersion
pkgJobs Package
pkg) [Char]
"cabal.project" forall a b. (a -> b) -> a -> b
$ [Char]
"packages: $GITHUB_WORKSPACE/source/" forall a. [a] -> [a] -> [a]
++ Package -> [Char]
pkgDir Package
pkg
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"cat cabal.project"

        [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"sdist" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"mkdir -p sdist"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"$CABAL sdist all --output-dir $GITHUB_WORKSPACE/sdist"

        [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"unpack" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"mkdir -p unpacked"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"find sdist -maxdepth 1 -type f -name '*.tar.gz' -exec tar -C $GITHUB_WORKSPACE/unpacked -xzvf {} \\;"

        [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"generate cabal.project" forall a b. (a -> b) -> a -> b
$ do
            forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Package]
pkgs forall a b. (a -> b) -> a -> b
$ \Pkg{[Char]
pkgName :: Package -> [Char]
pkgName :: [Char]
pkgName} -> do
                forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char] -> [Char]
pkgNameDirVariable' [Char]
pkgName forall a. [a] -> [a] -> [a]
++ [Char]
"=\"$(find \"$GITHUB_WORKSPACE/unpacked\" -maxdepth 1 -type d -regex '.*/" forall a. [a] -> [a] -> [a]
++ [Char]
pkgName forall a. [a] -> [a] -> [a]
++ [Char]
"-[0-9.]*')\""
                [Char] -> [Char] -> ShM ()
tell_env ([Char] -> [Char]
pkgNameDirVariable' [Char]
pkgName) ([Char] -> [Char]
pkgNameDirVariable [Char]
pkgName)

            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"rm -f cabal.project cabal.project.local"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"touch cabal.project"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"touch cabal.project.local"

            forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Package]
pkgs forall a b. (a -> b) -> a -> b
$ \Package
pkg ->
                CompilerRange -> [Char] -> [Char] -> ShM ()
echo_if_to (Set CompilerVersion -> CompilerRange
RangePoints forall a b. (a -> b) -> a -> b
$ Package -> Set CompilerVersion
pkgJobs Package
pkg) [Char]
"cabal.project" forall a b. (a -> b) -> a -> b
$ [Char]
"packages: " forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
pkgNameDirVariable (Package -> [Char]
pkgName Package
pkg)

            -- per package options
            case PackageScope
cfgErrorMissingMethods of
                PackageScope
PackageScopeNone  -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
                PackageScope
PackageScopeLocal -> forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Package]
pkgs forall a b. (a -> b) -> a -> b
$ \Pkg{[Char]
pkgName :: [Char]
pkgName :: Package -> [Char]
pkgName,Set CompilerVersion
pkgJobs :: Set CompilerVersion
pkgJobs :: Package -> Set CompilerVersion
pkgJobs} -> do
                    let range :: CompilerRange
range = VersionRange -> CompilerRange
Range (Version -> VersionRange
C.orLaterVersion ([Int] -> Version
C.mkVersion [Int
8,Int
2])) forall a. Lattice a => a -> a -> a
/\ Set CompilerVersion -> CompilerRange
RangePoints Set CompilerVersion
pkgJobs
                    CompilerRange -> [Char] -> [Char] -> ShM ()
echo_if_to CompilerRange
range [Char]
"cabal.project" forall a b. (a -> b) -> a -> b
$ [Char]
"package " forall a. [a] -> [a] -> [a]
++ [Char]
pkgName
                    CompilerRange -> [Char] -> [Char] -> ShM ()
echo_if_to CompilerRange
range [Char]
"cabal.project" forall a b. (a -> b) -> a -> b
$ [Char]
"    ghc-options: -Werror=missing-methods"
                PackageScope
PackageScopeAll   -> [Char] -> [Char] -> ShM ()
cat [Char]
"cabal.project" forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unlines
                    [ [Char]
"package *"
                    , [Char]
"  ghc-options: -Werror=missing-methods -Werror=missing-fields"
                    ]

            -- extra cabal.project fields
            [Char] -> [Char] -> ShM ()
cat [Char]
"cabal.project" forall a b. (a -> b) -> a -> b
$ forall ann.
(ann -> CommentPosition)
-> (ann -> [[Char]] -> [[Char]])
-> Int
-> [PrettyField ann]
-> [Char]
C.showFields' (forall a b. a -> b -> a
const CommentPosition
C.NoComment) (forall a b. a -> b -> a
const forall a. a -> a
id) Int
2 forall a b. (a -> b) -> a -> b
$ [Char] -> [PrettyField ()]
extraCabalProjectFields [Char]
"$GITHUB_WORKSPACE/source/"

            -- If using head.hackage, allow building with newer versions of GHC boot libraries.
            -- Note that we put this in a cabal.project file, not ~/.cabal/config, in order to avoid
            -- https://github.com/haskell/cabal/issues/7291.
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
anyJobUsesHeadHackage forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat forall a b. (a -> b) -> a -> b
$
                [ [Char]
"if $HEADHACKAGE; then\n"
                , [Char]
"echo \"allow-newer: $($HCPKG list --simple-output | sed -E 's/([a-zA-Z-]+)-[0-9.]+/*:\\1,/g')\" >> cabal.project\n"
                , [Char]
"fi"
                ]

            -- also write cabal.project.local file with
            -- @
            -- constraints: base installed
            -- constraints: array installed
            -- ...
            --
            -- omitting any local package names
            case [Installed] -> InstalledNormalised
normaliseInstalled [Installed]
cfgInstalled of
                InstalledDiff Set PackageName
pns -> forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unwords
                    [ [Char]
"$HCPKG list --simple-output --names-only"
                    , [Char]
"| perl -ne 'for (split /\\s+/) { print \"constraints: $_ installed\\n\" unless /" forall a. [a] -> [a] -> [a]
++ [Char]
re forall a. [a] -> [a] -> [a]
++ [Char]
"/; }'"
                    , [Char]
">> cabal.project.local"
                    ]
                  where
                    pns' :: Set [Char]
pns' = forall b a. Ord b => (a -> b) -> Set a -> Set b
S.map PackageName -> [Char]
C.unPackageName Set PackageName
pns forall a. Ord a => Set a -> Set a -> Set a
`S.union` forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (forall a. a -> Set a
S.singleton forall b c a. (b -> c) -> (a -> b) -> a -> c
. Package -> [Char]
pkgName) [Package]
pkgs
                    re :: [Char]
re = [Char]
"^(" forall a. [a] -> [a] -> [a]
++ forall a. [a] -> [[a]] -> [a]
intercalate [Char]
"|" (forall a. Set a -> [a]
S.toList Set [Char]
pns') forall a. [a] -> [a] -> [a]
++ [Char]
")$"

                InstalledOnly Set PackageName
pns | Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => t a -> Bool
null Set [Char]
pns') -> [Char] -> [Char] -> ShM ()
cat [Char]
"cabal.project.local" forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unlines
                    [ [Char]
"constraints: " forall a. [a] -> [a] -> [a]
++ [Char]
pkg forall a. [a] -> [a] -> [a]
++ [Char]
" installed"
                    | [Char]
pkg <- forall a. Set a -> [a]
S.toList Set [Char]
pns'
                    ]
                  where
                    pns' :: Set [Char]
pns' = forall b a. Ord b => (a -> b) -> Set a -> Set b
S.map PackageName -> [Char]
C.unPackageName Set PackageName
pns forall a. Ord a => Set a -> Set a -> Set a
`S.difference` forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (forall a. a -> Set a
S.singleton forall b c a. (b -> c) -> (a -> b) -> a -> c
. Package -> [Char]
pkgName) [Package]
pkgs

                -- otherwise: nothing
                InstalledNormalised
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"cat cabal.project"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"cat cabal.project.local"

        [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"dump install plan" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"$CABAL v2-build $ARG_COMPILER $ARG_TESTS $ARG_BENCH --dry-run all"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"cabal-plan"

        -- This a hack. https://github.com/actions/cache/issues/109
        -- Hashing Java - Maven style.
        [Char]
-> [Char]
-> [([Char], [Char])]
-> ListBuilder (Either HsCiError GitHubStep) ()
githubUses [Char]
"restore cache" [Char]
"actions/cache/restore@v3"
            [ ([Char]
"key", [Char]
"${{ runner.os }}-${{ matrix.compiler }}-${{ github.sha }}")
            , ([Char]
"restore-keys", [Char]
"${{ runner.os }}-${{ matrix.compiler }}-")
            , ([Char]
"path", [Char]
"~/.cabal/store")
            ]

        -- install dependencies
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
cfgInstallDeps forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"install dependencies" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"$CABAL v2-build $ARG_COMPILER --disable-tests --disable-benchmarks --dependencies-only -j2 all"
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"$CABAL v2-build $ARG_COMPILER $ARG_TESTS $ARG_BENCH --dependencies-only -j2 all"

        -- build w/o tests benchs
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (VersionRange -> VersionRange -> Bool
equivVersionRanges VersionRange
C.noVersion VersionRange
cfgNoTestsNoBench) forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"build w/o tests" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"$CABAL v2-build $ARG_COMPILER --disable-tests --disable-benchmarks all"

        -- build
        [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"build" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"$CABAL v2-build $ARG_COMPILER $ARG_TESTS $ARG_BENCH all --write-ghc-environment-files=always"

        -- tests
        [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"tests" forall a b. (a -> b) -> a -> b
$ do
            let range :: CompilerRange
range = CompilerRange
RangeGHC forall a. Lattice a => a -> a -> a
/\ VersionRange -> CompilerRange
Range (VersionRange
cfgTests forall a. Lattice a => a -> a -> a
/\ VersionRange
cfgRunTests) forall a. Lattice a => a -> a -> a
/\ CompilerRange
hasTests
            CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
range forall a b. (a -> b) -> a -> b
$ [Char]
"$CABAL v2-test $ARG_COMPILER $ARG_TESTS $ARG_BENCH all" forall a. [a] -> [a] -> [a]
++ [Char]
testShowDetails

            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
anyGHCJS Bool -> Bool -> Bool
&& Bool
cfgGhcjsTests) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unlines forall a b. (a -> b) -> a -> b
$
                [ [Char]
"pkgdir() {"
                , [Char]
"  case $1 in"
                ] forall a. [a] -> [a] -> [a]
++
                [ [Char]
"    " forall a. [a] -> [a] -> [a]
++ [Char]
pkgName forall a. [a] -> [a] -> [a]
++ [Char]
") echo " forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
pkgNameDirVariable [Char]
pkgName forall a. [a] -> [a] -> [a]
++ [Char]
" ;;"
                | Pkg{[Char]
pkgName :: [Char]
pkgName :: Package -> [Char]
pkgName} <- [Package]
pkgs
                ] forall a. [a] -> [a] -> [a]
++
                [ [Char]
"  esac"
                , [Char]
"}"
                ]

            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
cfgGhcjsTests forall a b. (a -> b) -> a -> b
$ CompilerRange -> [Char] -> ShM ()
sh_if (CompilerRange
RangeGHCJS forall a. Lattice a => a -> a -> a
/\ CompilerRange
hasTests) forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unwords
                [ [Char]
"cabal-plan list-bins '*:test:*' | while read -r line; do"
                , [Char]
"testpkg=$(echo \"$line\" | perl -pe 's/:.*//');"
                , [Char]
"testexe=$(echo \"$line\" | awk '{ print $2 }');"
                , [Char]
"echo \"testing $textexe in package $textpkg\";"
                , [Char]
"(cd \"$(pkgdir $testpkg)\" && nodejs \"$testexe\".jsexe/all.js);"
                , [Char]
"done"
                ]

        -- doctest
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
doctestEnabled forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"doctest" forall a b. (a -> b) -> a -> b
$ do
            let doctestOptions :: [Char]
doctestOptions = [[Char]] -> [Char]
unwords forall a b. (a -> b) -> a -> b
$ DoctestConfig -> [[Char]]
cfgDoctestOptions DoctestConfig
cfgDoctest

            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
null forall a b. (a -> b) -> a -> b
$ DoctestConfig -> [PackageName]
cfgDoctestFilterEnvPkgs DoctestConfig
cfgDoctest) forall a b. (a -> b) -> a -> b
$ do
                -- cabal-install mangles unit ids on the OSX,
                -- removing the vowels to make filepaths shorter
                let manglePkgNames :: String -> [String]
                    manglePkgNames :: [Char] -> [[Char]]
manglePkgNames [Char]
n
                        | forall (t :: * -> *) a. Foldable t => t a -> Bool
null Set CompilerVersion
macosVersions = [[Char]
n]
                        | Bool
otherwise          = [[Char]
n, forall a. (a -> Bool) -> [a] -> [a]
filter Char -> Bool
notVowel [Char]
n]
                      where
                        notVowel :: Char -> Bool
notVowel Char
c = forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
notElem Char
c ([Char]
"aeiou" :: String)
                let filterPkgs :: [Char]
filterPkgs = forall a. [a] -> [[a]] -> [a]
intercalate [Char]
"|" forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ([Char] -> [[Char]]
manglePkgNames forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageName -> [Char]
C.unPackageName) forall a b. (a -> b) -> a -> b
$ DoctestConfig -> [PackageName]
cfgDoctestFilterEnvPkgs DoctestConfig
cfgDoctest
                forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char]
"perl -i -e 'while (<ARGV>) { print unless /package-id\\s+(" forall a. [a] -> [a] -> [a]
++ [Char]
filterPkgs forall a. [a] -> [a] -> [a]
++ [Char]
")-\\d+(\\.\\d+)*/; }' .ghc.environment.*"

            forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Package]
pkgs forall a b. (a -> b) -> a -> b
$ \Pkg{[Char]
pkgName :: [Char]
pkgName :: Package -> [Char]
pkgName,GenericPackageDescription
pkgGpd :: Package -> GenericPackageDescription
pkgGpd :: GenericPackageDescription
pkgGpd,Set CompilerVersion
pkgJobs :: Set CompilerVersion
pkgJobs :: Package -> Set CompilerVersion
pkgJobs} ->
                forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when ([Char] -> PackageName
C.mkPackageName [Char]
pkgName forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` DoctestConfig -> [PackageName]
cfgDoctestFilterSrcPkgs DoctestConfig
cfgDoctest) forall a b. (a -> b) -> a -> b
$ do
                    forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (GenericPackageDescription -> [[[Char]]]
doctestArgs GenericPackageDescription
pkgGpd) forall a b. (a -> b) -> a -> b
$ \[[Char]]
args -> do
                        let args' :: [Char]
args' = [[Char]] -> [Char]
unwords [[Char]]
args
                        let vr :: CompilerRange
vr = VersionRange -> CompilerRange
Range (DoctestConfig -> VersionRange
cfgDoctestEnabled DoctestConfig
cfgDoctest)
                              forall a. Lattice a => a -> a -> a
/\ CompilerRange
doctestJobVersionRange
                              forall a. Lattice a => a -> a -> a
/\ Set CompilerVersion -> CompilerRange
RangePoints Set CompilerVersion
pkgJobs

                        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [[Char]]
args) forall a b. (a -> b) -> a -> b
$ do
                            CompilerRange -> [Char] -> ShM ()
change_dir_if CompilerRange
vr forall a b. (a -> b) -> a -> b
$ [Char] -> [Char]
pkgNameDirVariable [Char]
pkgName
                            CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
vr forall a b. (a -> b) -> a -> b
$ [Char]
"doctest " forall a. [a] -> [a] -> [a]
++ [Char]
doctestOptions forall a. [a] -> [a] -> [a]
++ [Char]
" " forall a. [a] -> [a] -> [a]
++ [Char]
args'

        -- docspec
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
docspecEnabled forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"docspec" forall a b. (a -> b) -> a -> b
$ do
            -- docspec doesn't work with non-GHC (i.e. GHCJS)
            let docspecRange' :: CompilerRange
docspecRange' = CompilerRange
docspecRange forall a. Lattice a => a -> a -> a
/\ CompilerRange
RangeGHC
            -- we need to rebuild, if tests screwed something.
            CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
docspecRange' [Char]
"$CABAL v2-build $ARG_COMPILER $ARG_TESTS $ARG_BENCH all"
            CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
docspecRange' [Char]
cabalDocspec

        -- hlint
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (HLintConfig -> Bool
cfgHLintEnabled HLintConfig
cfgHLint) forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"hlint" forall a b. (a -> b) -> a -> b
$ do
            let [Char]
"" <+> :: [Char] -> [Char] -> [Char]
<+> [Char]
ys = [Char]
ys
                [Char]
xs <+> [Char]
"" = [Char]
xs
                [Char]
xs <+> [Char]
ys = [Char]
xs forall a. [a] -> [a] -> [a]
++ [Char]
" " forall a. [a] -> [a] -> [a]
++ [Char]
ys

                prependSpace :: [Char] -> [Char]
prependSpace [Char]
"" = [Char]
""
                prependSpace [Char]
xs = [Char]
" " forall a. [a] -> [a] -> [a]
++ [Char]
xs

            let hlintOptions :: [Char]
hlintOptions = [Char] -> [Char]
prependSpace forall a b. (a -> b) -> a -> b
$ forall b a. b -> (a -> b) -> Maybe a -> b
maybe [Char]
"" ([Char]
"-h ${GITHUB_WORKSPACE}/source/" forall a. [a] -> [a] -> [a]
++) (HLintConfig -> Maybe [Char]
cfgHLintYaml HLintConfig
cfgHLint) [Char] -> [Char] -> [Char]
<+> [[Char]] -> [Char]
unwords (HLintConfig -> [[Char]]
cfgHLintOptions HLintConfig
cfgHLint)

            forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Package]
pkgs forall a b. (a -> b) -> a -> b
$ \Pkg{[Char]
pkgName :: [Char]
pkgName :: Package -> [Char]
pkgName,GenericPackageDescription
pkgGpd :: GenericPackageDescription
pkgGpd :: Package -> GenericPackageDescription
pkgGpd,Set CompilerVersion
pkgJobs :: Set CompilerVersion
pkgJobs :: Package -> Set CompilerVersion
pkgJobs} -> do
                forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (GenericPackageDescription -> [[[Char]]]
hlintArgs GenericPackageDescription
pkgGpd) forall a b. (a -> b) -> a -> b
$ \[[Char]]
args -> do
                    let args' :: [Char]
args' = [[Char]] -> [Char]
unwords [[Char]]
args
                    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [[Char]]
args) forall a b. (a -> b) -> a -> b
$
                        CompilerRange -> [Char] -> ShM ()
sh_if (Set CompilerVersion -> VersionRange -> HLintJob -> CompilerRange
hlintJobVersionRange Set CompilerVersion
allVersions VersionRange
cfgHeadHackage (HLintConfig -> HLintJob
cfgHLintJob HLintConfig
cfgHLint) forall a. Lattice a => a -> a -> a
/\ Set CompilerVersion -> CompilerRange
RangePoints Set CompilerVersion
pkgJobs) forall a b. (a -> b) -> a -> b
$
                        [Char]
"(cd " forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
pkgNameDirVariable [Char]
pkgName forall a. [a] -> [a] -> [a]
++ [Char]
" && hlint" forall a. [a] -> [a] -> [a]
++ [Char]
hlintOptions forall a. [a] -> [a] -> [a]
++ [Char]
" " forall a. [a] -> [a] -> [a]
++ [Char]
args' forall a. [a] -> [a] -> [a]
++ [Char]
")"

        -- cabal check
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
cfgCheck forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"cabal check" forall a b. (a -> b) -> a -> b
$ do
            forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [Package]
pkgs forall a b. (a -> b) -> a -> b
$ \Pkg{[Char]
pkgName :: [Char]
pkgName :: Package -> [Char]
pkgName,Set CompilerVersion
pkgJobs :: Set CompilerVersion
pkgJobs :: Package -> Set CompilerVersion
pkgJobs} -> do
                let range :: CompilerRange
range = Set CompilerVersion -> CompilerRange
RangePoints Set CompilerVersion
pkgJobs
                CompilerRange -> [Char] -> ShM ()
change_dir_if CompilerRange
range forall a b. (a -> b) -> a -> b
$ [Char] -> [Char]
pkgNameDirVariable [Char]
pkgName
                CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
range [Char]
"${CABAL} -vnormal check"

        -- haddock
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
runHaddock forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"haddock" forall a b. (a -> b) -> a -> b
$ do
            let range :: CompilerRange
range = CompilerRange
RangeGHC forall a. Lattice a => a -> a -> a
/\ VersionRange -> CompilerRange
Range VersionRange
cfgHaddock
            -- disable-documentation disables docs in deps: https://github.com/haskell/cabal/issues/7462
            CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
range forall a b. (a -> b) -> a -> b
$ [Char]
"$CABAL v2-haddock --disable-documentation" forall a. [a] -> [a] -> [a]
++ [Char]
haddockFlags forall a. [a] -> [a] -> [a]
++ [Char]
" $ARG_COMPILER --with-haddock $HADDOCK $ARG_TESTS $ARG_BENCH all"

        -- unconstrained build
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (VersionRange -> VersionRange -> Bool
equivVersionRanges VersionRange
C.noVersion VersionRange
cfgUnconstrainted) forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"unconstrained build" forall a b. (a -> b) -> a -> b
$ do
            let range :: CompilerRange
range = VersionRange -> CompilerRange
Range VersionRange
cfgUnconstrainted
            CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
range [Char]
"rm -f cabal.project.local"
            CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
range [Char]
"$CABAL v2-build $ARG_COMPILER --disable-tests --disable-benchmarks all"

        -- constraint sets
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [ConstraintSet]
cfgConstraintSets) forall a b. (a -> b) -> a -> b
$ [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
"prepare for constraint sets" forall a b. (a -> b) -> a -> b
$ do
            forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
"rm -f cabal.project.local"

        forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [ConstraintSet]
cfgConstraintSets forall a b. (a -> b) -> a -> b
$ \ConstraintSet
cs -> [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun ([Char]
"constraint set " forall a. [a] -> [a] -> [a]
++ ConstraintSet -> [Char]
csName ConstraintSet
cs) forall a b. (a -> b) -> a -> b
$ do
            let range :: CompilerRange
range
                  | ConstraintSet -> Bool
csGhcjs ConstraintSet
cs  = VersionRange -> CompilerRange
Range (ConstraintSet -> VersionRange
csGhcVersions ConstraintSet
cs)
                  | Bool
otherwise   = CompilerRange
RangeGHC forall a. Lattice a => a -> a -> a
/\ VersionRange -> CompilerRange
Range (ConstraintSet -> VersionRange
csGhcVersions ConstraintSet
cs)

            let sh_cs :: [Char] -> ShM ()
sh_cs           = CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
range
            let sh_cs' :: CompilerRange -> [Char] -> ShM ()
sh_cs' CompilerRange
r        = CompilerRange -> [Char] -> ShM ()
sh_if (CompilerRange
range forall a. Lattice a => a -> a -> a
/\ CompilerRange
r)
            let testFlag :: [Char]
testFlag        = if ConstraintSet -> Bool
csTests ConstraintSet
cs then [Char]
"--enable-tests" else [Char]
"--disable-tests"
            let benchFlag :: [Char]
benchFlag       = if ConstraintSet -> Bool
csBenchmarks ConstraintSet
cs then [Char]
"--enable-benchmarks" else [Char]
"--disable-benchmarks"
            let constraintFlags :: [[Char]]
constraintFlags = forall a b. (a -> b) -> [a] -> [b]
map (\[Char]
x ->  [Char]
"--constraint='" forall a. [a] -> [a] -> [a]
++ [Char]
x forall a. [a] -> [a] -> [a]
++ [Char]
"'") (ConstraintSet -> [[Char]]
csConstraints ConstraintSet
cs)
            let allFlags :: [Char]
allFlags        = [[Char]] -> [Char]
unwords ([Char]
testFlag forall a. a -> [a] -> [a]
: [Char]
benchFlag forall a. a -> [a] -> [a]
: [[Char]]
constraintFlags)

            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
cfgInstallDeps forall a b. (a -> b) -> a -> b
$ [Char] -> ShM ()
sh_cs forall a b. (a -> b) -> a -> b
$ [Char]
"$CABAL v2-build $ARG_COMPILER " forall a. [a] -> [a] -> [a]
++ [Char]
allFlags forall a. [a] -> [a] -> [a]
++ [Char]
" --dependencies-only -j2 all"
            [Char] -> ShM ()
sh_cs forall a b. (a -> b) -> a -> b
$ [Char]
"$CABAL v2-build $ARG_COMPILER " forall a. [a] -> [a] -> [a]
++ [Char]
allFlags forall a. [a] -> [a] -> [a]
++ [Char]
" all"
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
docspecEnabled Bool -> Bool -> Bool
&& ConstraintSet -> Bool
csDocspec ConstraintSet
cs) forall a b. (a -> b) -> a -> b
$
                CompilerRange -> [Char] -> ShM ()
sh_cs' CompilerRange
docspecRange [Char]
cabalDocspec
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (ConstraintSet -> Bool
csRunTests ConstraintSet
cs) forall a b. (a -> b) -> a -> b
$
                CompilerRange -> [Char] -> ShM ()
sh_cs' CompilerRange
hasTests forall a b. (a -> b) -> a -> b
$ [Char]
"$CABAL v2-test $ARG_COMPILER " forall a. [a] -> [a] -> [a]
++ [Char]
allFlags forall a. [a] -> [a] -> [a]
++ [Char]
" all"
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (ConstraintSet -> Bool
csHaddock ConstraintSet
cs) forall a b. (a -> b) -> a -> b
$
                [Char] -> ShM ()
sh_cs forall a b. (a -> b) -> a -> b
$ [Char]
"$CABAL v2-haddock --disable-documentation" forall a. [a] -> [a] -> [a]
++ [Char]
haddockFlags forall a. [a] -> [a] -> [a]
++ [Char]
" $ARG_COMPILER " forall a. [a] -> [a] -> [a]
++ [Char]
withHaddock forall a. [a] -> [a] -> [a]
++ [Char]
" " forall a. [a] -> [a] -> [a]
++ [Char]
allFlags forall a. [a] -> [a] -> [a]
++ [Char]
" all"

        [Char]
-> [Char]
-> [Char]
-> [([Char], [Char])]
-> ListBuilder (Either HsCiError GitHubStep) ()
githubUsesIf [Char]
"save cache" [Char]
"actions/cache/save@v3" [Char]
"always()"
          [ ([Char]
"key", [Char]
"${{ runner.os }}-${{ matrix.compiler }}-${{ github.sha }}")
          , ([Char]
"path", [Char]
"~/.cabal/store")
          ]

    -- assembling everything
    forall (m :: * -> *) a. Monad m => a -> m a
return GitHub
        { ghName :: [Char]
ghName = [Char]
actionName
        , ghOn :: GitHubOn
ghOn = GitHubOn
            { ghBranches :: [[Char]]
ghBranches = [[Char]]
cfgOnlyBranches
            }
        , ghJobs :: Map [Char] GitHubJob
ghJobs = forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList forall a b. (a -> b) -> a -> b
$ forall x. ListBuilder x () -> [x]
buildList forall a b. (a -> b) -> a -> b
$ do
            forall x. x -> ListBuilder x ()
item ([Char]
mainJobName, GitHubJob
                { ghjName :: [Char]
ghjName            = [Char]
actionName forall a. [a] -> [a] -> [a]
++ [Char]
" - Linux - ${{ matrix.compiler }}"
                  -- NB: The Ubuntu version used in `runs-on` isn't
                  -- particularly important since we use a Docker container.
                , ghjRunsOn :: [Char]
ghjRunsOn          = [Char]
ghcRunsOnVer
                , ghjNeeds :: [[Char]]
ghjNeeds           = []
                , ghjSteps :: [GitHubStep]
ghjSteps           = [GitHubStep]
steps
                , ghjIf :: Maybe [Char]
ghjIf              = forall a. Maybe a
Nothing
                , ghjContainer :: Maybe [Char]
ghjContainer       = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ [Char]
"buildpack-deps:" forall a. [a] -> [a] -> [a]
++ [Char]
ubuntuVer
                , ghjContinueOnError :: Maybe [Char]
ghjContinueOnError = forall a. a -> Maybe a
Just [Char]
"${{ matrix.allow-failure }}"
                , ghjServices :: Map [Char] GitHubService
ghjServices        = forall a. Monoid a => [a] -> a
mconcat
                    [ forall k a. k -> a -> Map k a
Map.singleton [Char]
"postgres" GitHubService
postgresService | Bool
cfgPostgres ]
                , ghjTimeout :: Natural
ghjTimeout         = forall a. Ord a => a -> a -> a
max Natural
10 Natural
cfgTimeoutMinutes
                , ghjMatrix :: [GitHubMatrixEntry]
ghjMatrix          =
                    [ GitHubMatrixEntry
                        { ghmeCompiler :: CompilerVersion
ghmeCompiler     = CompilerVersion -> CompilerVersion
translateCompilerVersion forall a b. (a -> b) -> a -> b
$ CompilerVersion
compiler
                        , ghmeAllowFailure :: Bool
ghmeAllowFailure =
                               VersionRange -> CompilerVersion -> Bool
previewGHC VersionRange
cfgHeadHackage CompilerVersion
compiler
                            Bool -> Bool -> Bool
|| forall a. a -> (Version -> a) -> CompilerVersion -> a
maybeGHC Bool
False (Version -> VersionRange -> Bool
`C.withinRange` VersionRange
cfgAllowFailures) CompilerVersion
compiler
                        , ghmeSetupMethod :: SetupMethod
ghmeSetupMethod = if CompilerVersion -> Bool
isGHCUP CompilerVersion
compiler then SetupMethod
GHCUP else SetupMethod
HVRPPA
                        }
                    | CompilerVersion
compiler <- forall a. [a] -> [a]
reverse forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Set CompilerVersion
linuxVersions
                    , CompilerVersion
compiler forall a. Eq a => a -> a -> Bool
/= CompilerVersion
GHCHead -- TODO: Make this work
                                          -- https://github.com/haskell-CI/haskell-ci/issues/458
                    ]
                })
            forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [[Char]]
cfgIrcChannels) forall a b. (a -> b) -> a -> b
$
                [Char]
-> [Char]
-> [Char]
-> Config
-> GitConfig
-> ListBuilder ([Char], GitHubJob) ()
ircJob [Char]
actionName [Char]
mainJobName [Char]
projectName Config
config GitConfig
gitconfig
        }
  where
    actionName :: [Char]
actionName  = forall a. a -> Maybe a -> a
fromMaybe [Char]
"Haskell-CI" Maybe [Char]
cfgGitHubActionName
    mainJobName :: [Char]
mainJobName = [Char]
"linux"

    ubuntuVer :: [Char]
ubuntuVer    = Ubuntu -> [Char]
showUbuntu Ubuntu
cfgUbuntu
    cabalVer :: [Char]
cabalVer     = Maybe Version -> [Char]
dispCabalVersion Maybe Version
cfgCabalInstallVersion
    cabalFullVer :: [Char]
cabalFullVer = Maybe Version -> [Char]
dispCabalVersion forall a b. (a -> b) -> a -> b
$ Version -> Version
cabalGhcupVersion forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Version
cfgCabalInstallVersion

    Auxiliary {Bool
[Char]
[URI]
[Package]
CompilerRange
[Char] -> [PrettyField ()]
haddockFlags :: Auxiliary -> [Char]
runHaddock :: Auxiliary -> Bool
anyJobUsesHeadHackage :: Auxiliary -> Bool
testShowDetails :: Auxiliary -> [Char]
extraCabalProjectFields :: Auxiliary -> [Char] -> [PrettyField ()]
hasLibrary :: Auxiliary -> Bool
hasTests :: Auxiliary -> CompilerRange
docspecEnabled :: Auxiliary -> Bool
doctestEnabled :: Auxiliary -> Bool
projectName :: Auxiliary -> [Char]
uris :: Auxiliary -> [URI]
pkgs :: Auxiliary -> [Package]
hasLibrary :: Bool
uris :: [URI]
projectName :: [Char]
haddockFlags :: [Char]
runHaddock :: Bool
testShowDetails :: [Char]
hasTests :: CompilerRange
extraCabalProjectFields :: [Char] -> [PrettyField ()]
pkgs :: [Package]
docspecEnabled :: Bool
doctestEnabled :: Bool
anyJobUsesHeadHackage :: Bool
..} = Config -> Project URI Void Package -> JobVersions -> Auxiliary
auxiliary Config
config Project URI Void Package
prj JobVersions
jobs

    anyGHCJS :: Bool
anyGHCJS = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any CompilerVersion -> Bool
isGHCJS Set CompilerVersion
allVersions
    anyGHCUP :: Bool
anyGHCUP = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any CompilerVersion -> Bool
isGHCUP Set CompilerVersion
allVersions
    allGHCUP :: Bool
allGHCUP = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all CompilerVersion -> Bool
isGHCUP Set CompilerVersion
allVersions

    -- Generate a setup block for hvr-ppa or ghcup, or both.
    setup :: [Sh] -> [Sh] -> ShM ()
    setup :: [Sh] -> [Sh] -> ShM ()
setup [Sh]
hvrppa [Sh]
ghcup
        | Bool
allGHCUP     = forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ Sh -> ShM ()
liftSh [Sh]
ghcup
        | Bool -> Bool
not Bool
anyGHCUP = forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ Sh -> ShM ()
liftSh [Sh]
hvrppa
        -- SC2192: ${{ ...}} will match (ShellCheck think it doesn't)
        -- SC2129: individual redirects
        -- SC2296: Parameter expansions can't start with {. Double check syntax. -- ${{ }} in YAML templating.
        | Bool
otherwise    = forall (m :: * -> *). MonadSh m => [Integer] -> [Char] -> m ()
sh' [Integer
2193, Integer
2129, Integer
2296] forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unlines forall a b. (a -> b) -> a -> b
$
            [ [Char]
"if [ \"${{ matrix.setup-method }}\" = ghcup ]; then"
            ] forall a. [a] -> [a] -> [a]
++
            [ [Char]
"  " forall a. [a] -> [a] -> [a]
++ Sh -> [Char]
shToString Sh
s
            | Sh
s <- [Sh]
ghcup
            ] forall a. [a] -> [a] -> [a]
++
            [ [Char]
"else"
            ] forall a. [a] -> [a] -> [a]
++
            [ [Char]
"  " forall a. [a] -> [a] -> [a]
++ Sh -> [Char]
shToString Sh
s
            | Sh
s <- [Sh]
hvrppa
            ] forall a. [a] -> [a] -> [a]
++
            [ [Char]
"fi"
            ]

    -- job to be setup with ghcup
    isGHCUP :: CompilerVersion -> Bool
    isGHCUP :: CompilerVersion -> Bool
isGHCUP CompilerVersion
v = CompilerVersion -> CompilerRange -> Bool
compilerWithinRange CompilerVersion
v (CompilerRange
RangeGHC forall a. Lattice a => a -> a -> a
/\ VersionRange -> CompilerRange
Range VersionRange
cfgGhcupJobs)

    -- step primitives
    githubRun' :: String -> Map.Map String String ->  ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
    githubRun' :: [Char]
-> Map [Char] [Char]
-> ShM ()
-> ListBuilder (Either HsCiError GitHubStep) ()
githubRun' [Char]
name Map [Char] [Char]
env ShM ()
shm = forall x. x -> ListBuilder x ()
item forall a b. (a -> b) -> a -> b
$ do
        [Sh]
shs <- forall e (m :: * -> *).
(MonadErr e m, FromHsCiError e) =>
ShM () -> m [Sh]
runSh ShM ()
shm
        forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Char] -> Either GitHubRun GitHubUses -> GitHubStep
GitHubStep [Char]
name forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left forall a b. (a -> b) -> a -> b
$ [Sh] -> Map [Char] [Char] -> GitHubRun
GitHubRun [Sh]
shs Map [Char] [Char]
env

    githubRun :: String -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
    githubRun :: [Char] -> ShM () -> ListBuilder (Either HsCiError GitHubStep) ()
githubRun [Char]
name = [Char]
-> Map [Char] [Char]
-> ShM ()
-> ListBuilder (Either HsCiError GitHubStep) ()
githubRun' [Char]
name forall a. Monoid a => a
mempty

    githubUses :: String -> String -> [(String, String)] -> ListBuilder (Either HsCiError GitHubStep) ()
    githubUses :: [Char]
-> [Char]
-> [([Char], [Char])]
-> ListBuilder (Either HsCiError GitHubStep) ()
githubUses [Char]
name [Char]
action [([Char], [Char])]
with = forall x. x -> ListBuilder x ()
item forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
        [Char] -> Either GitHubRun GitHubUses -> GitHubStep
GitHubStep [Char]
name forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ [Char] -> Maybe [Char] -> Map [Char] [Char] -> GitHubUses
GitHubUses [Char]
action forall a. Maybe a
Nothing (forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [([Char], [Char])]
with)

    githubUsesIf :: String -> String -> String -> [(String, String)] -> ListBuilder (Either HsCiError GitHubStep) ()
    githubUsesIf :: [Char]
-> [Char]
-> [Char]
-> [([Char], [Char])]
-> ListBuilder (Either HsCiError GitHubStep) ()
githubUsesIf [Char]
name [Char]
action [Char]
if_ [([Char], [Char])]
with = forall x. x -> ListBuilder x ()
item forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
        [Char] -> Either GitHubRun GitHubUses -> GitHubStep
GitHubStep [Char]
name forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ [Char] -> Maybe [Char] -> Map [Char] [Char] -> GitHubUses
GitHubUses [Char]
action (forall a. a -> Maybe a
Just [Char]
if_) (forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [([Char], [Char])]
with)

    -- shell primitives
    echo_to' :: FilePath -> String -> String
    echo_to' :: [Char] -> [Char] -> [Char]
echo_to' [Char]
fp [Char]
s = [Char]
"echo " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show [Char]
s forall a. [a] -> [a] -> [a]
++ [Char]
" >> " forall a. [a] -> [a] -> [a]
++ [Char]
fp

    echo_to :: FilePath -> String -> ShM ()
    echo_to :: [Char] -> [Char] -> ShM ()
echo_to [Char]
fp [Char]
s = forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char] -> [Char] -> [Char]
echo_to' [Char]
fp [Char]
s

    echo_if_to :: CompilerRange -> FilePath -> String -> ShM ()
    echo_if_to :: CompilerRange -> [Char] -> [Char] -> ShM ()
echo_if_to CompilerRange
range [Char]
fp [Char]
s = CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
range forall a b. (a -> b) -> a -> b
$ [Char] -> [Char] -> [Char]
echo_to' [Char]
fp [Char]
s

    change_dir_if :: CompilerRange -> String -> ShM ()
    change_dir_if :: CompilerRange -> [Char] -> ShM ()
change_dir_if CompilerRange
range [Char]
dir = CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
range ([Char]
"cd " forall a. [a] -> [a] -> [a]
++ [Char]
dir forall a. [a] -> [a] -> [a]
++ [Char]
" || false")

    tell_env' :: String -> String -> String
    tell_env' :: [Char] -> [Char] -> [Char]
tell_env' [Char]
k [Char]
v = [Char]
"echo " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show ([Char]
k forall a. [a] -> [a] -> [a]
++ [Char]
"=" forall a. [a] -> [a] -> [a]
++ [Char]
v) forall a. [a] -> [a] -> [a]
++ [Char]
" >> \"$GITHUB_ENV\""

    tell_env :: String -> String -> ShM ()
    tell_env :: [Char] -> [Char] -> ShM ()
tell_env [Char]
k [Char]
v = forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char] -> [Char] -> [Char]
tell_env' [Char]
k [Char]
v

    if_then_else :: CompilerRange -> String -> String -> ShM ()
    if_then_else :: CompilerRange -> [Char] -> [Char] -> ShM ()
if_then_else CompilerRange
range [Char]
con [Char]
alt
        | forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (CompilerVersion -> CompilerRange -> Bool
`compilerWithinRange` CompilerRange
range) Set CompilerVersion
allVersions       = forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
con
        | Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (CompilerVersion -> CompilerRange -> Bool
`compilerWithinRange` CompilerRange
range) Set CompilerVersion
allVersions = forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
alt
        | Bool
otherwise = forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unwords
        [ [Char]
"if ["
        , Set CompilerVersion -> CompilerRange -> [Char]
compilerVersionArithPredicate Set CompilerVersion
allVersions CompilerRange
range
        , [Char]
"-ne 0 ]"
        , [Char]
"; then"
        , [Char]
con
        , [Char]
";"
        , [Char]
"else"
        , [Char]
alt
        , [Char]
";"
        , [Char]
"fi"
        ]

    sh_if :: CompilerRange -> String -> ShM ()
    sh_if :: CompilerRange -> [Char] -> ShM ()
sh_if CompilerRange
range [Char]
con
        | forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (CompilerVersion -> CompilerRange -> Bool
`compilerWithinRange` CompilerRange
range) Set CompilerVersion
allVersions       = forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh [Char]
con
        | Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (CompilerVersion -> CompilerRange -> Bool
`compilerWithinRange` CompilerRange
range) Set CompilerVersion
allVersions = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
        | Bool
otherwise = forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [[Char]] -> [Char]
unwords
        [ [Char]
"if ["
        , Set CompilerVersion -> CompilerRange -> [Char]
compilerVersionArithPredicate Set CompilerVersion
allVersions CompilerRange
range
        , [Char]
"-ne 0 ]"
        , [Char]
"; then"
        , [Char]
con
        , [Char]
";"
        , [Char]
"fi"
        ]

    -- Needed to work around haskell/cabal#6214
    withHaddock :: String
    withHaddock :: [Char]
withHaddock = [Char]
"--with-haddock $HADDOCK"

    cabalDocspec :: String
    cabalDocspec :: [Char]
cabalDocspec =
      let docspecOptions :: [[Char]]
docspecOptions = DocspecConfig -> [[Char]]
cfgDocspecOptions DocspecConfig
cfgDocspec in
      [[Char]] -> [Char]
unwords forall a b. (a -> b) -> a -> b
$ [Char]
"cabal-docspec $ARG_COMPILER" forall a. a -> [a] -> [a]
: [[Char]]
docspecOptions

    docspecRange :: CompilerRange
    docspecRange :: CompilerRange
docspecRange = VersionRange -> CompilerRange
Range (DocspecConfig -> VersionRange
cfgDocspecEnabled DocspecConfig
cfgDocspec)

postgresService :: GitHubService
postgresService :: GitHubService
postgresService = GitHubService
    { ghServImage :: [Char]
ghServImage   = [Char]
"postgres:14"
    , ghServOptions :: Maybe [Char]
ghServOptions = forall a. a -> Maybe a
Just [Char]
"--health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5"
    , ghServEnv :: Map [Char] [Char]
ghServEnv     = forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
          [ ([Char]
"POSTGRES_PASSWORD", [Char]
"postgres")
          ]
    }

ircJob :: String -> String -> String -> Config -> GitConfig -> ListBuilder (String, GitHubJob) ()
ircJob :: [Char]
-> [Char]
-> [Char]
-> Config
-> GitConfig
-> ListBuilder ([Char], GitHubJob) ()
ircJob [Char]
actionName [Char]
mainJobName [Char]
projectName Config
cfg GitConfig
gitconfig = forall x. x -> ListBuilder x ()
item ([Char]
"irc", GitHubJob
    { ghjName :: [Char]
ghjName            = [Char]
actionName forall a. [a] -> [a] -> [a]
++ [Char]
" (IRC notification)"
    , ghjRunsOn :: [Char]
ghjRunsOn          = [Char]
ghcRunsOnVer
    , ghjNeeds :: [[Char]]
ghjNeeds           = [[Char]
mainJobName]
    , ghjIf :: Maybe [Char]
ghjIf              = Maybe [Char]
jobCondition
    , ghjContainer :: Maybe [Char]
ghjContainer       = forall a. Maybe a
Nothing
    , ghjContinueOnError :: Maybe [Char]
ghjContinueOnError = forall a. Maybe a
Nothing
    , ghjMatrix :: [GitHubMatrixEntry]
ghjMatrix          = []
    , ghjServices :: Map [Char] GitHubService
ghjServices        = forall a. Monoid a => a
mempty
    , ghjSteps :: [GitHubStep]
ghjSteps           = [ [Char] -> Bool -> GitHubStep
ircStep [Char]
serverChannelName Bool
success
                           | [Char]
serverChannelName <- [[Char]]
serverChannelNames
                           , Bool
success <- [Bool
True, Bool
False]
                           ]
    , ghjTimeout :: Natural
ghjTimeout         = Natural
10
    })
  where
    serverChannelNames :: [[Char]]
serverChannelNames = Config -> [[Char]]
cfgIrcChannels Config
cfg

    jobCondition :: Maybe String
    jobCondition :: Maybe [Char]
jobCondition
        | Config -> Bool
cfgIrcIfInOriginRepo Config
cfg
        , Just Text
url <- forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Text
"origin" (GitConfig -> Map Text Text
gitCfgRemotes GitConfig
gitconfig)
        , Just Text
repo <- Text -> Maybe Text
parseGitHubRepo Text
url

        = forall a. a -> Maybe a
Just
        forall a b. (a -> b) -> a -> b
$ [Char]
"${{ always() && (github.repository == '" forall a. [a] -> [a] -> [a]
++ Text -> [Char]
T.unpack Text
repo forall a. [a] -> [a] -> [a]
++ [Char]
"') }}"

        | Bool
otherwise
        = forall a. a -> Maybe a
Just [Char]
"${{ always() }}"
        -- Use always() above to ensure that the IRC job will still run even if
        -- the build job itself fails (see #437).

    ircStep :: String -> Bool -> GitHubStep
    ircStep :: [Char] -> Bool -> GitHubStep
ircStep [Char]
serverChannelName Bool
success =
        let ([Char]
serverName, [Char]
channelName) = forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== Char
'#') [Char]
serverChannelName

            result :: [Char]
result | Bool
success   = [Char]
"success"
                   | Bool
otherwise = [Char]
"failure"

            resultPastTense :: [Char]
resultPastTense | Bool
success   = [Char]
"succeeded"
                            | Bool
otherwise = [Char]
"failed"

            eqCheck :: [Char]
eqCheck | Bool
success   = [Char]
"=="
                    | Bool
otherwise = [Char]
"!=" in

        [Char] -> Either GitHubRun GitHubUses -> GitHubStep
GitHubStep ([Char]
"IRC " forall a. [a] -> [a] -> [a]
++ [Char]
result forall a. [a] -> [a] -> [a]
++ [Char]
" notification (" forall a. [a] -> [a] -> [a]
++ [Char]
serverChannelName forall a. [a] -> [a] -> [a]
++ [Char]
")") forall a b. (a -> b) -> a -> b
$ forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$
        [Char] -> Maybe [Char] -> Map [Char] [Char] -> GitHubUses
GitHubUses [Char]
"Gottox/irc-message-action@v2"
                   (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ [Char]
"needs." forall a. [a] -> [a] -> [a]
++ [Char]
mainJobName forall a. [a] -> [a] -> [a]
++ [Char]
".result " forall a. [a] -> [a] -> [a]
++ [Char]
eqCheck forall a. [a] -> [a] -> [a]
++ [Char]
" 'success'") forall a b. (a -> b) -> a -> b
$
        forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList forall a b. (a -> b) -> a -> b
$ forall x. ListBuilder x () -> [x]
buildList forall a b. (a -> b) -> a -> b
$ do
            forall x. x -> ListBuilder x ()
item ([Char]
"server",   [Char]
serverName)
            forall x. x -> ListBuilder x ()
item ([Char]
"channel",  [Char]
channelName)
            forall x. x -> ListBuilder x ()
item ([Char]
"nickname", forall a. a -> Maybe a -> a
fromMaybe [Char]
"github-actions" forall a b. (a -> b) -> a -> b
$ Config -> Maybe [Char]
cfgIrcNickname Config
cfg)
            forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ (Config -> Maybe [Char]
cfgIrcPassword Config
cfg) forall a b. (a -> b) -> a -> b
$ \[Char]
p ->
                forall x. x -> ListBuilder x ()
item ([Char]
"sasl_password", [Char]
p)
            forall x. x -> ListBuilder x ()
item ([Char]
"message",  [Char]
"\x0313" forall a. [a] -> [a] -> [a]
++ [Char]
projectName forall a. [a] -> [a] -> [a]
++ [Char]
"\x03/\x0306${{ github.ref }}\x03 "
                                       forall a. [a] -> [a] -> [a]
++ [Char]
"\x0314${{ github.sha }}\x03 "
                                       forall a. [a] -> [a] -> [a]
++ [Char]
"https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }} "
                                       forall a. [a] -> [a] -> [a]
++ [Char]
"The build " forall a. [a] -> [a] -> [a]
++ [Char]
resultPastTense forall a. [a] -> [a] -> [a]
++ [Char]
".")

catCmd :: FilePath -> String -> String
catCmd :: [Char] -> [Char] -> [Char]
catCmd [Char]
path [Char]
contents = forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat
    [ [Char]
"cat >> " forall a. [a] -> [a] -> [a]
++ [Char]
path forall a. [a] -> [a] -> [a]
++ [Char]
" <<EOF\n"
    , [Char]
contents
    , [Char]
"EOF"
    ]

cat :: FilePath -> String -> ShM ()
cat :: [Char] -> [Char] -> ShM ()
cat [Char]
path [Char]
contents = forall (m :: * -> *). MonadSh m => [Char] -> m ()
sh forall a b. (a -> b) -> a -> b
$ [Char] -> [Char] -> [Char]
catCmd [Char]
path [Char]
contents

-- | GitHub is very lenient and undocumented. We accept something.
-- Please, write a patch, if you need an extra scheme to be accepted.
--
-- >>> parseGitHubRepo "git@github.com:haskell-CI/haskell-ci.git"
-- Just "haskell-CI/haskell-ci"
--
-- >>> parseGitHubRepo "git@github.com:haskell-CI/haskell-ci"
-- Just "haskell-CI/haskell-ci"
--
-- >>> parseGitHubRepo "https://github.com/haskell-CI/haskell-ci.git"
-- Just "haskell-CI/haskell-ci"
--
-- >>> parseGitHubRepo "https://github.com/haskell-CI/haskell-ci"
-- Just "haskell-CI/haskell-ci"
--
-- >>> parseGitHubRepo "git://github.com/haskell-CI/haskell-ci"
-- Just "haskell-CI/haskell-ci"
--
parseGitHubRepo :: Text -> Maybe Text
parseGitHubRepo :: Text -> Maybe Text
parseGitHubRepo Text
t =
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const forall a. Maybe a
Nothing) forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a. Parser a -> Text -> Either [Char] a
Atto.parseOnly (Parser Text Text
parser forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall t. Chunk t => Parser t ()
Atto.endOfInput) Text
t
  where
    parser :: Atto.Parser Text
    parser :: Parser Text Text
parser = Parser Text Text
sshP forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Parser Text Text
httpsP

    sshP :: Atto.Parser Text
    sshP :: Parser Text Text
sshP = do
        Maybe Text
_ <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Text -> Parser Text Text
Atto.string Text
"git://")
        Text
_ <- Text -> Parser Text Text
Atto.string Text
"git@github.com:"
        Text
repo <- (Char -> Bool) -> Parser Text Text
Atto.takeWhile (forall a. Eq a => a -> a -> Bool
/= Char
'.')
        Maybe Text
_ <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Text -> Parser Text Text
Atto.string Text
".git")
        forall (m :: * -> *) a. Monad m => a -> m a
return Text
repo

    httpsP :: Atto.Parser Text
    httpsP :: Parser Text Text
httpsP = do
        Text
_ <- Text -> Parser Text Text
Atto.string Text
"https" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Text -> Parser Text Text
Atto.string Text
"git"
        Text
_ <- Text -> Parser Text Text
Atto.string Text
"://github.com/"
        Text
repo <- (Char -> Bool) -> Parser Text Text
Atto.takeWhile (forall a. Eq a => a -> a -> Bool
/= Char
'.')
        Maybe Text
_ <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Text -> Parser Text Text
Atto.string Text
".git")
        forall (m :: * -> *) a. Monad m => a -> m a
return Text
repo

-- NB: The Ubuntu version used in `runs-on` isn't particularly important since
-- we use a Docker container. We do make an attempt to keep it relatively up to
-- date to ensure that it runs on a version of Ubuntu that GitHub Actions
-- runners support.
ghcRunsOnVer :: String
ghcRunsOnVer :: [Char]
ghcRunsOnVer = [Char]
"ubuntu-20.04"