{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TupleSections #-}
module Distribution.Client.CmdInstall
(
installCommand
, installAction
, selectPackageTargets
, selectComponentTarget
, establishDummyDistDirLayout
, establishDummyProjectBaseContext
) where
import Distribution.Client.Compat.Prelude
import Distribution.Compat.Directory
( doesPathExist
)
import Prelude ()
import Distribution.Client.CmdErrorMessages
import Distribution.Client.CmdSdist
import Distribution.Client.ProjectOrchestration
import Distribution.Client.TargetProblem
( TargetProblem (..)
, TargetProblem'
)
import Distribution.Client.CmdInstall.ClientInstallFlags
import Distribution.Client.CmdInstall.ClientInstallTargetSelector
import Distribution.Client.Config
( SavedConfig (..)
, defaultInstallPath
, loadConfig
)
import Distribution.Client.DistDirLayout
( CabalDirLayout (..)
, DistDirLayout (..)
, StoreDirLayout (..)
, cabalStoreDirLayout
, mkCabalDirLayout
)
import Distribution.Client.IndexUtils
( getInstalledPackages
, getSourcePackages
)
import qualified Distribution.Client.InstallPlan as InstallPlan
import Distribution.Client.InstallSymlink
( Symlink (..)
, promptRun
, symlinkBinary
, symlinkableBinary
, trySymlink
)
import Distribution.Client.NixStyleOptions
( NixStyleFlags (..)
, cfgVerbosity
, defaultNixStyleFlags
, nixStyleOptions
)
import Distribution.Client.ProjectConfig
( ProjectPackageLocation (..)
, fetchAndReadSourcePackages
, projectConfigWithBuilderRepoContext
, resolveBuildTimeSettings
, withGlobalConfig
, withProjectOrGlobalConfig
)
import Distribution.Client.ProjectConfig.Types
( MapMappend (..)
, PackageConfig (..)
, ProjectConfig (..)
, ProjectConfigBuildOnly (..)
, ProjectConfigShared (..)
, getMapLast
, getMapMappend
, projectConfigBuildOnly
, projectConfigConfigFile
, projectConfigLogsDir
, projectConfigStoreDir
)
import Distribution.Client.ProjectFlags (ProjectFlags (..))
import Distribution.Client.ProjectPlanning
( storePackageInstallDirs'
)
import Distribution.Client.ProjectPlanning.Types
( ElaboratedInstallPlan
)
import Distribution.Client.RebuildMonad
( runRebuild
)
import Distribution.Client.Setup
( ConfigFlags (..)
, GlobalFlags (..)
, InstallFlags (..)
)
import Distribution.Client.Types
( PackageLocation (..)
, PackageSpecifier (..)
, SourcePackageDb (..)
, UnresolvedSourcePackage
, mkNamedPackage
, pkgSpecifierTarget
)
import Distribution.Client.Types.OverwritePolicy
( OverwritePolicy (..)
)
import Distribution.Package
( Package (..)
, PackageName
, mkPackageName
, unPackageName
)
import Distribution.Simple.BuildPaths
( exeExtension
)
import Distribution.Simple.Command
( CommandUI (..)
, optionName
, usageAlternatives
)
import Distribution.Simple.Compiler
( Compiler (..)
, CompilerFlavor (..)
, CompilerId (..)
, PackageDBCWD
, PackageDBStackCWD
, PackageDBX (..)
)
import Distribution.Simple.Configure
( configCompilerEx
)
import Distribution.Simple.Flag
( flagElim
, flagToMaybe
, fromFlagOrDefault
)
import Distribution.Simple.GHC
( GhcEnvironmentFileEntry (..)
, GhcImplInfo (..)
, ParseErrorExc
, getGhcAppDir
, getImplInfo
, ghcPlatformAndVersionString
, readGhcEnvironmentFile
, renderGhcEnvironmentFile
)
import qualified Distribution.Simple.InstallDirs as InstallDirs
import qualified Distribution.Simple.PackageIndex as PI
import Distribution.Simple.Program.Db
( defaultProgramDb
, prependProgramSearchPath
, userSpecifyArgss
, userSpecifyPaths
)
import Distribution.Simple.Setup
( Flag
, installDirsOptions
, pattern Flag
, pattern NoFlag
)
import Distribution.Simple.Utils
( createDirectoryIfMissingVerbose
, dieWithException
, notice
, ordNub
, safeHead
, warn
, withTempDirectory
, wrapText
)
import Distribution.Solver.Types.PackageConstraint
( PackageProperty (..)
)
import Distribution.Solver.Types.PackageIndex
( lookupPackageName
, searchByName
)
import Distribution.Solver.Types.SourcePackage
( SourcePackage (..)
)
import Distribution.System
( OS (Windows)
, Platform
, buildOS
)
import Distribution.Types.InstalledPackageInfo
( InstalledPackageInfo (..)
)
import Distribution.Types.PackageId
( PackageIdentifier (..)
)
import Distribution.Types.UnitId
( UnitId
)
import Distribution.Types.UnqualComponentName
( UnqualComponentName
, unUnqualComponentName
)
import Distribution.Types.Version
( Version
, nullVersion
)
import Distribution.Types.VersionRange
( thisVersion
)
import Distribution.Utils.Generic
( writeFileAtomic
)
import Distribution.Verbosity
( lessVerbose
, normal
)
import qualified Data.ByteString.Lazy.Char8 as BS
import qualified Data.List.NonEmpty as NE
import qualified Data.Map as Map
import Data.Ord
( Down (..)
)
import qualified Data.Set as S
import Distribution.Client.Errors
import Distribution.Utils.NubList
( fromNubList
)
import Network.URI (URI)
import System.Directory
( copyFile
, createDirectoryIfMissing
, doesDirectoryExist
, doesFileExist
, getTemporaryDirectory
, makeAbsolute
, removeDirectory
, removeFile
)
import System.FilePath
( takeBaseName
, takeDirectory
, (<.>)
, (</>)
)
data InstallCheck
=
InstallCheckOnly
|
InstallCheckInstall
type InstallAction =
Verbosity
-> OverwritePolicy
-> InstallExe
-> (UnitId, [(ComponentTarget, NonEmpty TargetSelector)])
-> IO ()
data InstallCfg = InstallCfg
{ InstallCfg -> Verbosity
verbosity :: Verbosity
, InstallCfg -> ProjectBaseContext
baseCtx :: ProjectBaseContext
, InstallCfg -> ProjectBuildContext
buildCtx :: ProjectBuildContext
, InstallCfg -> Platform
platform :: Platform
, InstallCfg -> Compiler
compiler :: Compiler
, InstallCfg -> ConfigFlags
installConfigFlags :: ConfigFlags
, InstallCfg -> ClientInstallFlags
installClientFlags :: ClientInstallFlags
}
data InstallExe = InstallExe
{ InstallExe -> InstallMethod
installMethod :: InstallMethod
, InstallExe -> [Char]
installDir :: FilePath
, InstallExe -> UnitId -> [Char]
mkSourceBinDir :: UnitId -> FilePath
, InstallExe -> UnqualComponentName -> [Char]
mkExeName :: UnqualComponentName -> FilePath
, InstallExe -> UnqualComponentName -> [Char]
mkFinalExeName :: UnqualComponentName -> FilePath
}
installCommand :: CommandUI (NixStyleFlags ClientInstallFlags)
installCommand :: CommandUI (NixStyleFlags ClientInstallFlags)
installCommand =
CommandUI
{ commandName :: [Char]
commandName = [Char]
"v2-install"
, commandSynopsis :: [Char]
commandSynopsis = [Char]
"Install packages."
, commandUsage :: [Char] -> [Char]
commandUsage =
[Char] -> [[Char]] -> [Char] -> [Char]
usageAlternatives
[Char]
"v2-install"
[[Char]
"[TARGETS] [FLAGS]"]
, commandDescription :: Maybe ([Char] -> [Char])
commandDescription = ([Char] -> [Char]) -> Maybe ([Char] -> [Char])
forall a. a -> Maybe a
Just (([Char] -> [Char]) -> Maybe ([Char] -> [Char]))
-> ([Char] -> [Char]) -> Maybe ([Char] -> [Char])
forall a b. (a -> b) -> a -> b
$ \[Char]
_ ->
[Char] -> [Char]
wrapText ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$
[Char]
"Installs one or more packages. This is done by installing them "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"in the store and symlinking or copying the executables in the directory "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"specified by the --installdir flag (`~/.local/bin/` by default). "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"If you want the installed executables to be available globally, "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"make sure that the PATH environment variable contains that directory. "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\n\n"
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"If TARGET is a library and --lib (provisional) is used, "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"it will be added to the global environment. "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"When doing this, cabal will try to build a plan that includes all "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"the previously installed libraries. This is currently not implemented."
, commandNotes :: Maybe ([Char] -> [Char])
commandNotes = ([Char] -> [Char]) -> Maybe ([Char] -> [Char])
forall a. a -> Maybe a
Just (([Char] -> [Char]) -> Maybe ([Char] -> [Char]))
-> ([Char] -> [Char]) -> Maybe ([Char] -> [Char])
forall a b. (a -> b) -> a -> b
$ \[Char]
pname ->
[Char]
"Examples:\n"
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
pname
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" v2-install\n"
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" Install the package in the current directory\n"
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
pname
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" v2-install pkgname\n"
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" Install the package named pkgname"
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" (fetching it from hackage if necessary)\n"
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
pname
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" v2-install ./pkgfoo\n"
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" Install the package in the ./pkgfoo directory\n"
, commandOptions :: ShowOrParseArgs -> [OptionField (NixStyleFlags ClientInstallFlags)]
commandOptions = \ShowOrParseArgs
x -> (OptionField (NixStyleFlags ClientInstallFlags) -> Bool)
-> [OptionField (NixStyleFlags ClientInstallFlags)]
-> [OptionField (NixStyleFlags ClientInstallFlags)]
forall a. (a -> Bool) -> [a] -> [a]
filter OptionField (NixStyleFlags ClientInstallFlags) -> Bool
forall {a}. OptionField a -> Bool
notInstallDirOpt ([OptionField (NixStyleFlags ClientInstallFlags)]
-> [OptionField (NixStyleFlags ClientInstallFlags)])
-> [OptionField (NixStyleFlags ClientInstallFlags)]
-> [OptionField (NixStyleFlags ClientInstallFlags)]
forall a b. (a -> b) -> a -> b
$ (ShowOrParseArgs -> [OptionField ClientInstallFlags])
-> ShowOrParseArgs
-> [OptionField (NixStyleFlags ClientInstallFlags)]
forall a.
(ShowOrParseArgs -> [OptionField a])
-> ShowOrParseArgs -> [OptionField (NixStyleFlags a)]
nixStyleOptions ShowOrParseArgs -> [OptionField ClientInstallFlags]
clientInstallOptions ShowOrParseArgs
x
, commandDefaultFlags :: NixStyleFlags ClientInstallFlags
commandDefaultFlags = ClientInstallFlags -> NixStyleFlags ClientInstallFlags
forall a. a -> NixStyleFlags a
defaultNixStyleFlags ClientInstallFlags
defaultClientInstallFlags
}
where
notInstallDirOpt :: OptionField a -> Bool
notInstallDirOpt OptionField a
x = Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ OptionField a -> [Char]
forall a. OptionField a -> [Char]
optionName OptionField a
x [Char] -> [[Char]] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [[Char]]
installDirOptNames
installDirOptNames :: [[Char]]
installDirOptNames = (OptionField (InstallDirs (Flag PathTemplate)) -> [Char])
-> [OptionField (InstallDirs (Flag PathTemplate))] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map OptionField (InstallDirs (Flag PathTemplate)) -> [Char]
forall a. OptionField a -> [Char]
optionName [OptionField (InstallDirs (Flag PathTemplate))]
installDirsOptions
installAction :: NixStyleFlags ClientInstallFlags -> [String] -> GlobalFlags -> IO ()
installAction :: NixStyleFlags ClientInstallFlags
-> [[Char]] -> GlobalFlags -> IO ()
installAction flags :: NixStyleFlags ClientInstallFlags
flags@NixStyleFlags{ClientInstallFlags
extraFlags :: ClientInstallFlags
extraFlags :: forall a. NixStyleFlags a -> a
extraFlags, ConfigFlags
configFlags :: ConfigFlags
configFlags :: forall a. NixStyleFlags a -> ConfigFlags
configFlags, InstallFlags
installFlags :: InstallFlags
installFlags :: forall a. NixStyleFlags a -> InstallFlags
installFlags, ProjectFlags
projectFlags :: ProjectFlags
projectFlags :: forall a. NixStyleFlags a -> ProjectFlags
projectFlags} [[Char]]
targetStrings GlobalFlags
globalFlags = do
Verbosity -> ConfigFlags -> IO ()
verifyPreconditionsOrDie Verbosity
verbosity ConfigFlags
configFlags'
clientInstallFlags <- Verbosity
-> GlobalFlags -> ClientInstallFlags -> IO ClientInstallFlags
getClientInstallFlags Verbosity
verbosity GlobalFlags
globalFlags ClientInstallFlags
extraFlags
let
installLibs = Bool -> Last Bool -> Bool
forall a. a -> Flag a -> a
fromFlagOrDefault Bool
False (ClientInstallFlags -> Last Bool
cinstInstallLibs ClientInstallFlags
clientInstallFlags)
normalisedTargetStrings = if [[Char]] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [[Char]]
targetStrings then [[Char]
"."] else [[Char]]
targetStrings
(pkgSpecs, uris, targetSelectors, config) <-
let
with = do
(pkgSpecs, targetSelectors, baseConfig) <-
Verbosity
-> ProjectConfig
-> [[Char]]
-> Bool
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)],
[TargetSelector], ProjectConfig)
withProject Verbosity
verbosity ProjectConfig
cliConfig [[Char]]
normalisedTargetStrings Bool
installLibs
return (pkgSpecs, [], targetSelectors, baseConfig)
without =
Verbosity
-> Flag [Char]
-> (ProjectConfig
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)], [URI],
[TargetSelector], ProjectConfig))
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)], [URI],
[TargetSelector], ProjectConfig)
forall a.
Verbosity -> Flag [Char] -> (ProjectConfig -> IO a) -> IO a
withGlobalConfig Verbosity
verbosity Flag [Char]
globalConfigFlag ((ProjectConfig
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)], [URI],
[TargetSelector], ProjectConfig))
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)], [URI],
[TargetSelector], ProjectConfig))
-> (ProjectConfig
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)], [URI],
[TargetSelector], ProjectConfig))
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)], [URI],
[TargetSelector], ProjectConfig)
forall a b. (a -> b) -> a -> b
$ \ProjectConfig
globalConfig ->
Verbosity
-> ProjectConfig
-> [[Char]]
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)], [URI],
[TargetSelector], ProjectConfig)
withoutProject Verbosity
verbosity (ProjectConfig
globalConfig ProjectConfig -> ProjectConfig -> ProjectConfig
forall a. Semigroup a => a -> a -> a
<> ProjectConfig
cliConfig) [[Char]]
normalisedTargetStrings
in
if null targetStrings
then with
else withProjectOrGlobalConfig ignoreProject with without
let
ProjectConfig
{ projectConfigBuildOnly =
ProjectConfigBuildOnly
{ projectConfigLogsDir
}
, projectConfigShared =
ProjectConfigShared
{ projectConfigHcFlavor
, projectConfigHcPath
, projectConfigHcPkg
, projectConfigStoreDir
, projectConfigProgPathExtra
, projectConfigPackageDBs
}
, projectConfigLocalPackages =
PackageConfig
{ packageConfigProgramPaths
, packageConfigProgramArgs
, packageConfigProgramPathExtra
}
} = config
hcFlavor = Flag CompilerFlavor -> Maybe CompilerFlavor
forall a. Flag a -> Maybe a
flagToMaybe Flag CompilerFlavor
projectConfigHcFlavor
hcPath = Flag [Char] -> Maybe [Char]
forall a. Flag a -> Maybe a
flagToMaybe Flag [Char]
projectConfigHcPath
hcPkg = Flag [Char] -> Maybe [Char]
forall a. Flag a -> Maybe a
flagToMaybe Flag [Char]
projectConfigHcPkg
extraPath = NubList [Char] -> [[Char]]
forall a. NubList a -> [a]
fromNubList NubList [Char]
packageConfigProgramPathExtra [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ NubList [Char] -> [[Char]]
forall a. NubList a -> [a]
fromNubList NubList [Char]
projectConfigProgPathExtra
configProgDb <- prependProgramSearchPath verbosity extraPath [] defaultProgramDb
let
preProgDb =
[([Char], [Char])] -> ProgramDb -> ProgramDb
userSpecifyPaths (Map [Char] [Char] -> [([Char], [Char])]
forall k a. Map k a -> [(k, a)]
Map.toList (MapLast [Char] [Char] -> Map [Char] [Char]
forall k v. MapLast k v -> Map k v
getMapLast MapLast [Char] [Char]
packageConfigProgramPaths))
(ProgramDb -> ProgramDb)
-> (ProgramDb -> ProgramDb) -> ProgramDb -> ProgramDb
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [([Char], [[Char]])] -> ProgramDb -> ProgramDb
userSpecifyArgss (Map [Char] [[Char]] -> [([Char], [[Char]])]
forall k a. Map k a -> [(k, a)]
Map.toList (MapMappend [Char] [[Char]] -> Map [Char] [[Char]]
forall k v. MapMappend k v -> Map k v
getMapMappend MapMappend [Char] [[Char]]
packageConfigProgramArgs))
(ProgramDb -> ProgramDb) -> ProgramDb -> ProgramDb
forall a b. (a -> b) -> a -> b
$ ProgramDb
configProgDb
(compiler@Compiler{compilerId = CompilerId compilerFlavor compilerVersion}, platform, progDb) <-
configCompilerEx hcFlavor hcPath hcPkg preProgDb verbosity
let
GhcImplInfo{supportsPkgEnvFiles} = getImplInfo compiler
(usedPackageEnvFlag, envFile) <- getEnvFile clientInstallFlags platform compilerVersion
(usedExistingPkgEnvFile, existingEnvEntries) <-
getExistingEnvEntries verbosity compilerFlavor supportsPkgEnvFiles envFile
packageDbs <- getPackageDbStack compiler projectConfigStoreDir projectConfigLogsDir projectConfigPackageDBs
installedIndex <- getInstalledPackages verbosity compiler packageDbs progDb
let
(envSpecs, nonGlobalEnvEntries) =
getEnvSpecsAndNonGlobalEntries installedIndex existingEnvEntries installLibs
globalTmp <- getTemporaryDirectory
withTempDirectory verbosity globalTmp "cabal-install." $ \[Char]
tmpDir -> do
distDirLayout <- Verbosity -> ProjectConfig -> [Char] -> IO DistDirLayout
establishDummyDistDirLayout Verbosity
verbosity ProjectConfig
config [Char]
tmpDir
uriSpecs <-
runRebuild tmpDir $
fetchAndReadSourcePackages
verbosity
distDirLayout
(Just compiler)
(projectConfigShared config)
(projectConfigBuildOnly config)
[ProjectPackageRemoteTarball uri | uri <- uris]
let getPackageName :: PackageSpecifier UnresolvedSourcePackage -> PackageName
getPackageName = PackageSpecifier (SourcePackage UnresolvedPkgLoc) -> PackageName
forall pkg. Package pkg => PackageSpecifier pkg -> PackageName
pkgSpecifierTarget
targetNames = [PackageName] -> Set PackageName
forall a. Ord a => [a] -> Set a
S.fromList ([PackageName] -> Set PackageName)
-> [PackageName] -> Set PackageName
forall a b. (a -> b) -> a -> b
$ (PackageSpecifier (SourcePackage UnresolvedPkgLoc) -> PackageName)
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
-> [PackageName]
forall a b. (a -> b) -> [a] -> [b]
map PackageSpecifier (SourcePackage UnresolvedPkgLoc) -> PackageName
getPackageName ([PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
pkgSpecs [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
forall a. [a] -> [a] -> [a]
++ [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
uriSpecs)
envNames = [PackageName] -> Set PackageName
forall a. Ord a => [a] -> Set a
S.fromList ([PackageName] -> Set PackageName)
-> [PackageName] -> Set PackageName
forall a b. (a -> b) -> a -> b
$ (PackageSpecifier (SourcePackage UnresolvedPkgLoc) -> PackageName)
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
-> [PackageName]
forall a b. (a -> b) -> [a] -> [b]
map PackageSpecifier (SourcePackage UnresolvedPkgLoc) -> PackageName
getPackageName [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
forall {a}. [PackageSpecifier a]
envSpecs
forceInstall = Bool -> Last Bool -> Bool
forall a. a -> Flag a -> a
fromFlagOrDefault Bool
False (Last Bool -> Bool) -> Last Bool -> Bool
forall a b. (a -> b) -> a -> b
$ InstallFlags -> Last Bool
installOverrideReinstall InstallFlags
installFlags
nameIntersection = Set PackageName -> Set PackageName -> Set PackageName
forall a. Ord a => Set a -> Set a -> Set a
S.intersection Set PackageName
targetNames Set PackageName
envNames
(envSpecs', nonGlobalEnvEntries') <-
if null nameIntersection
then pure (envSpecs, map snd nonGlobalEnvEntries)
else
if forceInstall
then
let es = (PackageSpecifier (SourcePackage UnresolvedPkgLoc) -> Bool)
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
forall a. (a -> Bool) -> [a] -> [a]
filter (\PackageSpecifier (SourcePackage UnresolvedPkgLoc)
e -> Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ PackageSpecifier (SourcePackage UnresolvedPkgLoc) -> PackageName
getPackageName PackageSpecifier (SourcePackage UnresolvedPkgLoc)
e PackageName -> Set PackageName -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set PackageName
nameIntersection) [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
forall {a}. [PackageSpecifier a]
envSpecs
nge = ((PackageName, GhcEnvironmentFileEntry [Char])
-> GhcEnvironmentFileEntry [Char])
-> [(PackageName, GhcEnvironmentFileEntry [Char])]
-> [GhcEnvironmentFileEntry [Char]]
forall a b. (a -> b) -> [a] -> [b]
map (PackageName, GhcEnvironmentFileEntry [Char])
-> GhcEnvironmentFileEntry [Char]
forall a b. (a, b) -> b
snd ([(PackageName, GhcEnvironmentFileEntry [Char])]
-> [GhcEnvironmentFileEntry [Char]])
-> ([(PackageName, GhcEnvironmentFileEntry [Char])]
-> [(PackageName, GhcEnvironmentFileEntry [Char])])
-> [(PackageName, GhcEnvironmentFileEntry [Char])]
-> [GhcEnvironmentFileEntry [Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((PackageName, GhcEnvironmentFileEntry [Char]) -> Bool)
-> [(PackageName, GhcEnvironmentFileEntry [Char])]
-> [(PackageName, GhcEnvironmentFileEntry [Char])]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(PackageName, GhcEnvironmentFileEntry [Char])
e -> Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ (PackageName, GhcEnvironmentFileEntry [Char]) -> PackageName
forall a b. (a, b) -> a
fst (PackageName, GhcEnvironmentFileEntry [Char])
e PackageName -> Set PackageName -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set PackageName
nameIntersection) ([(PackageName, GhcEnvironmentFileEntry [Char])]
-> [GhcEnvironmentFileEntry [Char]])
-> [(PackageName, GhcEnvironmentFileEntry [Char])]
-> [GhcEnvironmentFileEntry [Char]]
forall a b. (a -> b) -> a -> b
$ [(PackageName, GhcEnvironmentFileEntry [Char])]
nonGlobalEnvEntries
in pure (es, nge)
else dieWithException verbosity $ PackagesAlreadyExistInEnvfile envFile (map prettyShow $ S.toList nameIntersection)
let installedPacks = InstalledPackageIndex -> [(PackageName, [InstalledPackageInfo])]
forall a. PackageIndex a -> [(PackageName, [a])]
PI.allPackagesByName InstalledPackageIndex
installedIndex
newEnvNames = [PackageName] -> Set PackageName
forall a. Ord a => [a] -> Set a
S.fromList ([PackageName] -> Set PackageName)
-> [PackageName] -> Set PackageName
forall a b. (a -> b) -> a -> b
$ (PackageSpecifier (SourcePackage UnresolvedPkgLoc) -> PackageName)
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
-> [PackageName]
forall a b. (a -> b) -> [a] -> [b]
map PackageSpecifier (SourcePackage UnresolvedPkgLoc) -> PackageName
getPackageName [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
envSpecs'
installedIndex' = [InstalledPackageInfo] -> InstalledPackageIndex
PI.fromList ([InstalledPackageInfo] -> InstalledPackageIndex)
-> ([(PackageName, [InstalledPackageInfo])]
-> [InstalledPackageInfo])
-> [(PackageName, [InstalledPackageInfo])]
-> InstalledPackageIndex
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((PackageName, [InstalledPackageInfo]) -> [InstalledPackageInfo])
-> [(PackageName, [InstalledPackageInfo])]
-> [InstalledPackageInfo]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (PackageName, [InstalledPackageInfo]) -> [InstalledPackageInfo]
forall a b. (a, b) -> b
snd ([(PackageName, [InstalledPackageInfo])] -> [InstalledPackageInfo])
-> ([(PackageName, [InstalledPackageInfo])]
-> [(PackageName, [InstalledPackageInfo])])
-> [(PackageName, [InstalledPackageInfo])]
-> [InstalledPackageInfo]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((PackageName, [InstalledPackageInfo]) -> Bool)
-> [(PackageName, [InstalledPackageInfo])]
-> [(PackageName, [InstalledPackageInfo])]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(PackageName, [InstalledPackageInfo])
p -> (PackageName, [InstalledPackageInfo]) -> PackageName
forall a b. (a, b) -> a
fst (PackageName, [InstalledPackageInfo])
p PackageName -> Set PackageName -> Bool
forall a. Ord a => a -> Set a -> Bool
`S.member` Set PackageName
newEnvNames) ([(PackageName, [InstalledPackageInfo])] -> InstalledPackageIndex)
-> [(PackageName, [InstalledPackageInfo])] -> InstalledPackageIndex
forall a b. (a -> b) -> a -> b
$ [(PackageName, [InstalledPackageInfo])]
installedPacks
baseCtx <-
establishDummyProjectBaseContext
verbosity
config
distDirLayout
(envSpecs' ++ pkgSpecs ++ uriSpecs)
InstallCommand
buildCtx <- constructProjectBuildContext verbosity (baseCtx{installedPackages = Just installedIndex'}) targetSelectors
printPlan verbosity baseCtx buildCtx
let installCfg = Verbosity
-> ProjectBaseContext
-> ProjectBuildContext
-> Platform
-> Compiler
-> ConfigFlags
-> ClientInstallFlags
-> InstallCfg
InstallCfg Verbosity
verbosity ProjectBaseContext
baseCtx ProjectBuildContext
buildCtx Platform
platform Compiler
compiler ConfigFlags
configFlags ClientInstallFlags
clientInstallFlags
let
dryRun =
BuildTimeSettings -> Bool
buildSettingDryRun (ProjectBaseContext -> BuildTimeSettings
buildSettings ProjectBaseContext
baseCtx)
Bool -> Bool -> Bool
|| BuildTimeSettings -> Bool
buildSettingOnlyDownload (ProjectBaseContext -> BuildTimeSettings
buildSettings ProjectBaseContext
baseCtx)
unless
(dryRun || installLibs)
(traverseInstall (installCheckUnitExes InstallCheckOnly) installCfg)
buildOutcomes <- runProjectBuildPhase verbosity baseCtx buildCtx
runProjectPostBuildPhase verbosity baseCtx buildCtx buildOutcomes
unless dryRun $
if installLibs
then
installLibraries
verbosity
buildCtx
installedIndex
compiler
packageDbs
envFile
nonGlobalEnvEntries'
(not usedExistingPkgEnvFile && not usedPackageEnvFlag)
else
traverseInstall (installCheckUnitExes InstallCheckInstall) installCfg
where
configFlags' :: ConfigFlags
configFlags' = ConfigFlags -> ConfigFlags
disableTestsBenchsByDefault (ConfigFlags -> ConfigFlags)
-> (ConfigFlags -> ConfigFlags) -> ConfigFlags -> ConfigFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConfigFlags -> ConfigFlags
ignoreProgramAffixes (ConfigFlags -> ConfigFlags) -> ConfigFlags -> ConfigFlags
forall a b. (a -> b) -> a -> b
$ ConfigFlags
configFlags
verbosity :: Verbosity
verbosity = Verbosity -> NixStyleFlags ClientInstallFlags -> Verbosity
forall a. Verbosity -> NixStyleFlags a -> Verbosity
cfgVerbosity Verbosity
normal NixStyleFlags ClientInstallFlags
flags
ignoreProject :: Last Bool
ignoreProject = ProjectFlags -> Last Bool
flagIgnoreProject ProjectFlags
projectFlags
cliConfig :: ProjectConfig
cliConfig =
GlobalFlags
-> NixStyleFlags ClientInstallFlags
-> ClientInstallFlags
-> ProjectConfig
forall a.
GlobalFlags
-> NixStyleFlags a -> ClientInstallFlags -> ProjectConfig
commandLineFlagsToProjectConfig
GlobalFlags
globalFlags
NixStyleFlags ClientInstallFlags
flags{configFlags = configFlags'}
ClientInstallFlags
extraFlags
globalConfigFlag :: Flag [Char]
globalConfigFlag = ProjectConfigShared -> Flag [Char]
projectConfigConfigFile (ProjectConfig -> ProjectConfigShared
projectConfigShared ProjectConfig
cliConfig)
traverseInstall :: InstallAction -> InstallCfg -> IO ()
traverseInstall :: InstallAction -> InstallCfg -> IO ()
traverseInstall InstallAction
action cfg :: InstallCfg
cfg@InstallCfg{verbosity :: InstallCfg -> Verbosity
verbosity = Verbosity
v, ProjectBuildContext
buildCtx :: InstallCfg -> ProjectBuildContext
buildCtx :: ProjectBuildContext
buildCtx, ClientInstallFlags
installClientFlags :: InstallCfg -> ClientInstallFlags
installClientFlags :: ClientInstallFlags
installClientFlags} = do
let overwritePolicy :: OverwritePolicy
overwritePolicy = OverwritePolicy -> Flag OverwritePolicy -> OverwritePolicy
forall a. a -> Flag a -> a
fromFlagOrDefault OverwritePolicy
NeverOverwrite (Flag OverwritePolicy -> OverwritePolicy)
-> Flag OverwritePolicy -> OverwritePolicy
forall a b. (a -> b) -> a -> b
$ ClientInstallFlags -> Flag OverwritePolicy
cinstOverwritePolicy ClientInstallFlags
installClientFlags
actionOnExe <- InstallAction
action Verbosity
v OverwritePolicy
overwritePolicy (InstallExe
-> (UnitId, [(ComponentTarget, NonEmpty TargetSelector)]) -> IO ())
-> IO InstallExe
-> IO
((UnitId, [(ComponentTarget, NonEmpty TargetSelector)]) -> IO ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> InstallCfg -> IO InstallExe
prepareExeInstall InstallCfg
cfg
traverse_ actionOnExe . Map.toList $ targetsMap buildCtx
withProject
:: Verbosity
-> ProjectConfig
-> [String]
-> Bool
-> IO ([PackageSpecifier UnresolvedSourcePackage], [TargetSelector], ProjectConfig)
withProject :: Verbosity
-> ProjectConfig
-> [[Char]]
-> Bool
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)],
[TargetSelector], ProjectConfig)
withProject Verbosity
verbosity ProjectConfig
cliConfig [[Char]]
targetStrings Bool
installLibs = do
baseCtx <- Verbosity
-> ProjectConfig -> CurrentCommand -> IO ProjectBaseContext
establishProjectBaseContext Verbosity
reducedVerbosity ProjectConfig
cliConfig CurrentCommand
InstallCommand
(pkgSpecs, targetSelectors) <-
if null unresolvedTargetStrings
then return (parsedPkgSpecs, parsedTargets)
else do
(resolvedPkgSpecs, resolvedTargets) <-
resolveTargetSelectorsInProjectBaseContext verbosity baseCtx unresolvedTargetStrings targetFilter
return (resolvedPkgSpecs ++ parsedPkgSpecs, resolvedTargets ++ parsedTargets)
let config =
ProjectConfig -> [PackageName] -> ProjectConfig
addLocalConfigToPkgs (ProjectBaseContext -> ProjectConfig
projectConfig ProjectBaseContext
baseCtx) ([PackageName] -> ProjectConfig) -> [PackageName] -> ProjectConfig
forall a b. (a -> b) -> a -> b
$
(TargetSelector -> [PackageName])
-> [TargetSelector] -> [PackageName]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ([PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
-> TargetSelector -> [PackageName]
targetPkgNames ([PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
-> TargetSelector -> [PackageName])
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
-> TargetSelector
-> [PackageName]
forall a b. (a -> b) -> a -> b
$ ProjectBaseContext
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
localPackages ProjectBaseContext
baseCtx) [TargetSelector]
targetSelectors
return (pkgSpecs, targetSelectors, config)
where
reducedVerbosity :: Verbosity
reducedVerbosity = Verbosity -> Verbosity
lessVerbose Verbosity
verbosity
([[Char]]
unresolvedTargetStrings, [PackageIdentifier]
parsedPackageIds) =
[Either [Char] PackageIdentifier]
-> ([[Char]], [PackageIdentifier])
forall a b. [Either a b] -> ([a], [b])
partitionEithers ([Either [Char] PackageIdentifier]
-> ([[Char]], [PackageIdentifier]))
-> [Either [Char] PackageIdentifier]
-> ([[Char]], [PackageIdentifier])
forall a b. (a -> b) -> a -> b
$
(([Char] -> Either [Char] PackageIdentifier)
-> [[Char]] -> [Either [Char] PackageIdentifier])
-> [[Char]]
-> ([Char] -> Either [Char] PackageIdentifier)
-> [Either [Char] PackageIdentifier]
forall a b c. (a -> b -> c) -> b -> a -> c
flip ([Char] -> Either [Char] PackageIdentifier)
-> [[Char]] -> [Either [Char] PackageIdentifier]
forall a b. (a -> b) -> [a] -> [b]
map [[Char]]
targetStrings (([Char] -> Either [Char] PackageIdentifier)
-> [Either [Char] PackageIdentifier])
-> ([Char] -> Either [Char] PackageIdentifier)
-> [Either [Char] PackageIdentifier]
forall a b. (a -> b) -> a -> b
$ \[Char]
s ->
case [Char] -> Either [Char] PackageIdentifier
forall a. Parsec a => [Char] -> Either [Char] a
eitherParsec [Char]
s of
Right pkgId :: PackageIdentifier
pkgId@PackageIdentifier{Version
pkgVersion :: Version
pkgVersion :: PackageIdentifier -> Version
pkgVersion}
| Version
pkgVersion Version -> Version -> Bool
forall a. Eq a => a -> a -> Bool
/= Version
nullVersion ->
PackageIdentifier -> Either [Char] PackageIdentifier
forall a. a -> Either [Char] a
forall (f :: * -> *) a. Applicative f => a -> f a
pure PackageIdentifier
pkgId
Either [Char] PackageIdentifier
_ -> [Char] -> Either [Char] PackageIdentifier
forall a b. a -> Either a b
Left [Char]
s
([PackageSpecifier pkg]
parsedPkgSpecs, [TargetSelector]
parsedTargets) =
[(PackageSpecifier pkg, TargetSelector)]
-> ([PackageSpecifier pkg], [TargetSelector])
forall a b. [(a, b)] -> ([a], [b])
unzip
[ (PackageIdentifier -> PackageSpecifier pkg
forall pkg. PackageIdentifier -> PackageSpecifier pkg
mkNamedPackage PackageIdentifier
pkgId, PackageName -> Maybe ComponentKindFilter -> TargetSelector
TargetPackageNamed (PackageIdentifier -> PackageName
pkgName PackageIdentifier
pkgId) Maybe ComponentKindFilter
targetFilter)
| PackageIdentifier
pkgId <- [PackageIdentifier]
parsedPackageIds
]
targetFilter :: Maybe ComponentKindFilter
targetFilter = if Bool
installLibs then ComponentKindFilter -> Maybe ComponentKindFilter
forall a. a -> Maybe a
Just ComponentKindFilter
LibKind else ComponentKindFilter -> Maybe ComponentKindFilter
forall a. a -> Maybe a
Just ComponentKindFilter
ExeKind
resolveTargetSelectorsInProjectBaseContext
:: Verbosity
-> ProjectBaseContext
-> [String]
-> Maybe ComponentKindFilter
-> IO ([PackageSpecifier UnresolvedSourcePackage], [TargetSelector])
resolveTargetSelectorsInProjectBaseContext :: Verbosity
-> ProjectBaseContext
-> [[Char]]
-> Maybe ComponentKindFilter
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)],
[TargetSelector])
resolveTargetSelectorsInProjectBaseContext Verbosity
verbosity ProjectBaseContext
baseCtx [[Char]]
targetStrings Maybe ComponentKindFilter
targetFilter = do
let reducedVerbosity :: Verbosity
reducedVerbosity = Verbosity -> Verbosity
lessVerbose Verbosity
verbosity
sourcePkgDb <-
Verbosity
-> BuildTimeSettings
-> (RepoContext -> IO SourcePackageDb)
-> IO SourcePackageDb
forall a.
Verbosity -> BuildTimeSettings -> (RepoContext -> IO a) -> IO a
projectConfigWithBuilderRepoContext
Verbosity
reducedVerbosity
(ProjectBaseContext -> BuildTimeSettings
buildSettings ProjectBaseContext
baseCtx)
(Verbosity -> RepoContext -> IO SourcePackageDb
getSourcePackages Verbosity
verbosity)
targetSelectors <-
readTargetSelectors (localPackages baseCtx) Nothing targetStrings
>>= \case
Left [TargetSelectorProblem]
problems -> Verbosity -> [TargetSelectorProblem] -> IO [TargetSelector]
forall a. Verbosity -> [TargetSelectorProblem] -> IO a
reportTargetSelectorProblems Verbosity
verbosity [TargetSelectorProblem]
problems
Right [TargetSelector]
ts -> [TargetSelector] -> IO [TargetSelector]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [TargetSelector]
ts
getSpecsAndTargetSelectors
verbosity
reducedVerbosity
sourcePkgDb
targetSelectors
(distDirLayout baseCtx)
baseCtx
targetFilter
withoutProject
:: Verbosity
-> ProjectConfig
-> [String]
-> IO ([PackageSpecifier UnresolvedSourcePackage], [URI], [TargetSelector], ProjectConfig)
withoutProject :: Verbosity
-> ProjectConfig
-> [[Char]]
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)], [URI],
[TargetSelector], ProjectConfig)
withoutProject Verbosity
verbosity ProjectConfig
globalConfig [[Char]]
targetStrings = do
tss <- ([Char] -> IO WithoutProjectTargetSelector)
-> [[Char]] -> IO [WithoutProjectTargetSelector]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (Verbosity -> [Char] -> IO WithoutProjectTargetSelector
parseWithoutProjectTargetSelector Verbosity
verbosity) [[Char]]
targetStrings
let
ProjectConfigBuildOnly
{ projectConfigLogsDir
} = projectConfigBuildOnly globalConfig
ProjectConfigShared
{ projectConfigStoreDir
} = projectConfigShared globalConfig
mlogsDir = Flag [Char] -> Maybe [Char]
forall a. Flag a -> Maybe a
flagToMaybe Flag [Char]
projectConfigLogsDir
mstoreDir = Flag [Char] -> Maybe [Char]
forall a. Flag a -> Maybe a
flagToMaybe Flag [Char]
projectConfigStoreDir
cabalDirLayout <- mkCabalDirLayout mstoreDir mlogsDir
let buildSettings = Verbosity -> CabalDirLayout -> ProjectConfig -> BuildTimeSettings
resolveBuildTimeSettings Verbosity
verbosity CabalDirLayout
cabalDirLayout ProjectConfig
globalConfig
SourcePackageDb{packageIndex} <-
projectConfigWithBuilderRepoContext
verbosity
buildSettings
(getSourcePackages verbosity)
for_ (concatMap woPackageNames tss) $ \PackageName
name -> do
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when ([SourcePackage UnresolvedPkgLoc] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (PackageIndex (SourcePackage UnresolvedPkgLoc)
-> PackageName -> [SourcePackage UnresolvedPkgLoc]
forall pkg. Package pkg => PackageIndex pkg -> PackageName -> [pkg]
lookupPackageName PackageIndex (SourcePackage UnresolvedPkgLoc)
packageIndex PackageName
name)) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
let xs :: [(PackageName, [SourcePackage UnresolvedPkgLoc])]
xs = PackageIndex (SourcePackage UnresolvedPkgLoc)
-> [Char] -> [(PackageName, [SourcePackage UnresolvedPkgLoc])]
forall pkg. PackageIndex pkg -> [Char] -> [(PackageName, [pkg])]
searchByName PackageIndex (SourcePackage UnresolvedPkgLoc)
packageIndex (PackageName -> [Char]
unPackageName PackageName
name)
let emptyIf :: Bool -> [a] -> [a]
emptyIf Bool
True [a]
_ = []
emptyIf Bool
False [a]
zs = [a]
zs
str2 :: [[Char]]
str2 =
Bool -> [[Char]] -> [[Char]]
forall {a}. Bool -> [a] -> [a]
emptyIf
([(PackageName, [SourcePackage UnresolvedPkgLoc])] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(PackageName, [SourcePackage UnresolvedPkgLoc])]
xs)
[ [Char]
"Did you mean any of the following?\n"
, [[Char]] -> [Char]
unlines (([Char]
"- " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++) ([Char] -> [Char])
-> ((PackageName, [SourcePackage UnresolvedPkgLoc]) -> [Char])
-> (PackageName, [SourcePackage UnresolvedPkgLoc])
-> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageName -> [Char]
unPackageName (PackageName -> [Char])
-> ((PackageName, [SourcePackage UnresolvedPkgLoc]) -> PackageName)
-> (PackageName, [SourcePackage UnresolvedPkgLoc])
-> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PackageName, [SourcePackage UnresolvedPkgLoc]) -> PackageName
forall a b. (a, b) -> a
fst ((PackageName, [SourcePackage UnresolvedPkgLoc]) -> [Char])
-> [(PackageName, [SourcePackage UnresolvedPkgLoc])] -> [[Char]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(PackageName, [SourcePackage UnresolvedPkgLoc])]
xs)
]
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity (CabalInstallException -> IO ()) -> CabalInstallException -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]] -> CabalInstallException
WithoutProject (PackageName -> [Char]
unPackageName PackageName
name) [[Char]]
str2
let
packageSpecifiers :: [PackageSpecifier UnresolvedSourcePackage]
(uris, packageSpecifiers) = partitionEithers $ map woPackageSpecifiers tss
packageTargets = (WithoutProjectTargetSelector -> TargetSelector)
-> [WithoutProjectTargetSelector] -> [TargetSelector]
forall a b. (a -> b) -> [a] -> [b]
map WithoutProjectTargetSelector -> TargetSelector
woPackageTargets [WithoutProjectTargetSelector]
tss
let config = ProjectConfig -> [PackageName] -> ProjectConfig
addLocalConfigToPkgs ProjectConfig
globalConfig ((WithoutProjectTargetSelector -> [PackageName])
-> [WithoutProjectTargetSelector] -> [PackageName]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap WithoutProjectTargetSelector -> [PackageName]
woPackageNames [WithoutProjectTargetSelector]
tss)
return (packageSpecifiers, uris, packageTargets, config)
addLocalConfigToPkgs :: ProjectConfig -> [PackageName] -> ProjectConfig
addLocalConfigToPkgs :: ProjectConfig -> [PackageName] -> ProjectConfig
addLocalConfigToPkgs ProjectConfig
config [PackageName]
pkgs =
ProjectConfig
config
{ projectConfigSpecificPackage =
projectConfigSpecificPackage config
<> MapMappend (Map.fromList targetPackageConfigs)
}
where
localConfig :: PackageConfig
localConfig = ProjectConfig -> PackageConfig
projectConfigLocalPackages ProjectConfig
config
targetPackageConfigs :: [(PackageName, PackageConfig)]
targetPackageConfigs = (PackageName -> (PackageName, PackageConfig))
-> [PackageName] -> [(PackageName, PackageConfig)]
forall a b. (a -> b) -> [a] -> [b]
map (,PackageConfig
localConfig) [PackageName]
pkgs
targetPkgNames
:: [PackageSpecifier UnresolvedSourcePackage]
-> TargetSelector
-> [PackageName]
targetPkgNames :: [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
-> TargetSelector -> [PackageName]
targetPkgNames [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
localPkgs = \case
TargetPackage TargetImplicitCwd
_ [PackageIdentifier]
pkgIds Maybe ComponentKindFilter
_ -> (PackageIdentifier -> PackageName)
-> [PackageIdentifier] -> [PackageName]
forall a b. (a -> b) -> [a] -> [b]
map PackageIdentifier -> PackageName
pkgName [PackageIdentifier]
pkgIds
TargetPackageNamed PackageName
name Maybe ComponentKindFilter
_ -> [PackageName
name]
TargetAllPackages Maybe ComponentKindFilter
_ -> (PackageSpecifier (SourcePackage UnresolvedPkgLoc) -> PackageName)
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
-> [PackageName]
forall a b. (a -> b) -> [a] -> [b]
map PackageSpecifier (SourcePackage UnresolvedPkgLoc) -> PackageName
forall pkg. Package pkg => PackageSpecifier pkg -> PackageName
pkgSpecifierTarget [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
localPkgs
TargetComponent PackageIdentifier
pkgId ComponentName
_ SubComponentTarget
_ -> [PackageIdentifier -> PackageName
pkgName PackageIdentifier
pkgId]
TargetComponentUnknown PackageName
name Either UnqualComponentName ComponentName
_ SubComponentTarget
_ -> [PackageName
name]
verifyPreconditionsOrDie :: Verbosity -> ConfigFlags -> IO ()
verifyPreconditionsOrDie :: Verbosity -> ConfigFlags -> IO ()
verifyPreconditionsOrDie Verbosity
verbosity ConfigFlags
configFlags = do
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (ConfigFlags -> Last Bool
configTests ConfigFlags
configFlags Last Bool -> Last Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> Last Bool
forall a. a -> Last a
Flag Bool
True) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity CabalInstallException
ConfigTests
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (ConfigFlags -> Last Bool
configBenchmarks ConfigFlags
configFlags Last Bool -> Last Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool -> Last Bool
forall a. a -> Last a
Flag Bool
True) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity CabalInstallException
ConfigBenchmarks
getClientInstallFlags :: Verbosity -> GlobalFlags -> ClientInstallFlags -> IO ClientInstallFlags
getClientInstallFlags :: Verbosity
-> GlobalFlags -> ClientInstallFlags -> IO ClientInstallFlags
getClientInstallFlags Verbosity
verbosity GlobalFlags
globalFlags ClientInstallFlags
existingClientInstallFlags = do
let configFileFlag :: Flag [Char]
configFileFlag = GlobalFlags -> Flag [Char]
globalConfigFile GlobalFlags
globalFlags
savedConfig <- Verbosity -> Flag [Char] -> IO SavedConfig
loadConfig Verbosity
verbosity Flag [Char]
configFileFlag
pure $ savedClientInstallFlags savedConfig `mappend` existingClientInstallFlags
getSpecsAndTargetSelectors
:: Verbosity
-> Verbosity
-> SourcePackageDb
-> [TargetSelector]
-> DistDirLayout
-> ProjectBaseContext
-> Maybe ComponentKindFilter
-> IO ([PackageSpecifier UnresolvedSourcePackage], [TargetSelector])
getSpecsAndTargetSelectors :: Verbosity
-> Verbosity
-> SourcePackageDb
-> [TargetSelector]
-> DistDirLayout
-> ProjectBaseContext
-> Maybe ComponentKindFilter
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)],
[TargetSelector])
getSpecsAndTargetSelectors Verbosity
verbosity Verbosity
reducedVerbosity SourcePackageDb
sourcePkgDb [TargetSelector]
targetSelectors DistDirLayout
distDirLayout ProjectBaseContext
baseCtx Maybe ComponentKindFilter
targetFilter =
Verbosity
-> ProjectBaseContext
-> (ElaboratedInstallPlan
-> ElaboratedSharedConfig
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)],
[TargetSelector]))
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)],
[TargetSelector])
forall a.
Verbosity
-> ProjectBaseContext
-> (ElaboratedInstallPlan -> ElaboratedSharedConfig -> IO a)
-> IO a
withInstallPlan Verbosity
reducedVerbosity ProjectBaseContext
baseCtx ((ElaboratedInstallPlan
-> ElaboratedSharedConfig
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)],
[TargetSelector]))
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)],
[TargetSelector]))
-> (ElaboratedInstallPlan
-> ElaboratedSharedConfig
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)],
[TargetSelector]))
-> IO
([PackageSpecifier (SourcePackage UnresolvedPkgLoc)],
[TargetSelector])
forall a b. (a -> b) -> a -> b
$ \ElaboratedInstallPlan
elaboratedPlan ElaboratedSharedConfig
_ -> do
(targetsMap, hackageNames) <-
Verbosity
-> SourcePackageDb
-> ElaboratedInstallPlan
-> [TargetSelector]
-> IO (TargetsMap, [PackageName])
partitionToKnownTargetsAndHackagePackages
Verbosity
verbosity
SourcePackageDb
sourcePkgDb
ElaboratedInstallPlan
elaboratedPlan
[TargetSelector]
targetSelectors
let
planMap = ElaboratedInstallPlan
-> Map
UnitId
(GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage)
forall ipkg srcpkg.
GenericInstallPlan ipkg srcpkg
-> Map UnitId (GenericPlanPackage ipkg srcpkg)
InstallPlan.toMap ElaboratedInstallPlan
elaboratedPlan
sdistize (SpecificSourcePackage SourcePackage (PackageLocation local)
spkg) =
SourcePackage (PackageLocation local)
-> PackageSpecifier (SourcePackage (PackageLocation local))
forall pkg. pkg -> PackageSpecifier pkg
SpecificSourcePackage SourcePackage (PackageLocation local)
forall {local}. SourcePackage (PackageLocation local)
spkg'
where
sdistPath :: [Char]
sdistPath = DistDirLayout -> PackageIdentifier -> [Char]
distSdistFile DistDirLayout
distDirLayout (SourcePackage (PackageLocation local) -> PackageIdentifier
forall pkg. Package pkg => pkg -> PackageIdentifier
packageId SourcePackage (PackageLocation local)
spkg)
spkg' :: SourcePackage (PackageLocation local)
spkg' = SourcePackage (PackageLocation local)
spkg{srcpkgSource = LocalTarballPackage sdistPath}
sdistize PackageSpecifier (SourcePackage (PackageLocation local))
named = PackageSpecifier (SourcePackage (PackageLocation local))
named
localPkgs = PackageSpecifier (SourcePackage UnresolvedPkgLoc)
-> PackageSpecifier (SourcePackage UnresolvedPkgLoc)
forall {local}.
PackageSpecifier (SourcePackage (PackageLocation local))
-> PackageSpecifier (SourcePackage (PackageLocation local))
sdistize (PackageSpecifier (SourcePackage UnresolvedPkgLoc)
-> PackageSpecifier (SourcePackage UnresolvedPkgLoc))
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ProjectBaseContext
-> [PackageSpecifier (SourcePackage UnresolvedPkgLoc)]
localPackages ProjectBaseContext
baseCtx
gatherTargets :: UnitId -> TargetSelector
gatherTargets UnitId
targetId = PackageName -> Maybe ComponentKindFilter -> TargetSelector
TargetPackageNamed PackageName
pkgName Maybe ComponentKindFilter
targetFilter
where
targetUnit :: GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
targetUnit = GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> UnitId
-> Map
UnitId
(GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage)
-> GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage
forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault ([Char]
-> GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage
forall a. HasCallStack => [Char] -> a
error [Char]
"cannot find target unit") UnitId
targetId Map
UnitId
(GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage)
planMap
PackageIdentifier{Version
PackageName
pkgVersion :: PackageIdentifier -> Version
pkgName :: PackageIdentifier -> PackageName
pkgName :: PackageName
pkgVersion :: Version
..} = GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
-> PackageIdentifier
forall pkg. Package pkg => pkg -> PackageIdentifier
packageId GenericPlanPackage InstalledPackageInfo ElaboratedConfiguredPackage
targetUnit
localTargets = (UnitId -> TargetSelector) -> [UnitId] -> [TargetSelector]
forall a b. (a -> b) -> [a] -> [b]
map UnitId -> TargetSelector
gatherTargets (TargetsMap -> [UnitId]
forall k a. Map k a -> [k]
Map.keys TargetsMap
targetsMap)
hackagePkgs :: [PackageSpecifier UnresolvedSourcePackage]
hackagePkgs = [PackageName
-> [PackageProperty]
-> PackageSpecifier (SourcePackage UnresolvedPkgLoc)
forall pkg.
PackageName -> [PackageProperty] -> PackageSpecifier pkg
NamedPackage PackageName
pn [] | PackageName
pn <- [PackageName]
hackageNames]
hackageTargets :: [TargetSelector]
hackageTargets = [PackageName -> Maybe ComponentKindFilter -> TargetSelector
TargetPackageNamed PackageName
pn Maybe ComponentKindFilter
targetFilter | PackageName
pn <- [PackageName]
hackageNames]
createDirectoryIfMissing True (distSdistDirectory distDirLayout)
unless (Map.null targetsMap) $ for_ (localPackages baseCtx) $ \case
SpecificSourcePackage SourcePackage UnresolvedPkgLoc
pkg ->
Verbosity
-> [Char]
-> OutputFormat
-> [Char]
-> SourcePackage UnresolvedPkgLoc
-> IO ()
packageToSdist
Verbosity
verbosity
(DistDirLayout -> [Char]
distProjectRootDirectory DistDirLayout
distDirLayout)
OutputFormat
TarGzArchive
(DistDirLayout -> PackageIdentifier -> [Char]
distSdistFile DistDirLayout
distDirLayout (SourcePackage UnresolvedPkgLoc -> PackageIdentifier
forall pkg. Package pkg => pkg -> PackageIdentifier
packageId SourcePackage UnresolvedPkgLoc
pkg))
SourcePackage UnresolvedPkgLoc
pkg
NamedPackage PackageName
_ [PackageProperty]
_ ->
() -> IO ()
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
if null targetsMap
then return (hackagePkgs, hackageTargets)
else return (localPkgs ++ hackagePkgs, localTargets ++ hackageTargets)
partitionToKnownTargetsAndHackagePackages
:: Verbosity
-> SourcePackageDb
-> ElaboratedInstallPlan
-> [TargetSelector]
-> IO (TargetsMap, [PackageName])
partitionToKnownTargetsAndHackagePackages :: Verbosity
-> SourcePackageDb
-> ElaboratedInstallPlan
-> [TargetSelector]
-> IO (TargetsMap, [PackageName])
partitionToKnownTargetsAndHackagePackages Verbosity
verbosity SourcePackageDb
pkgDb ElaboratedInstallPlan
elaboratedPlan [TargetSelector]
targetSelectors = do
let mTargets :: Either [TargetProblem Void] TargetsMap
mTargets =
(forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem Void) [k])
-> (forall k.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem Void) k)
-> ElaboratedInstallPlan
-> Maybe SourcePackageDb
-> [TargetSelector]
-> Either [TargetProblem Void] TargetsMap
forall err.
(forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem err) [k])
-> (forall k.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem err) k)
-> ElaboratedInstallPlan
-> Maybe SourcePackageDb
-> [TargetSelector]
-> Either [TargetProblem err] TargetsMap
resolveTargetsFromSolver
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem Void) [k]
forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem Void) [k]
selectPackageTargets
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem Void) k
forall k.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem Void) k
selectComponentTarget
ElaboratedInstallPlan
elaboratedPlan
(SourcePackageDb -> Maybe SourcePackageDb
forall a. a -> Maybe a
Just SourcePackageDb
pkgDb)
[TargetSelector]
targetSelectors
case Either [TargetProblem Void] TargetsMap
mTargets of
Right TargetsMap
targets ->
(TargetsMap, [PackageName]) -> IO (TargetsMap, [PackageName])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TargetsMap
targets, [])
Left [TargetProblem Void]
errs -> do
let
([TargetProblem Void]
errs', [PackageName]
hackageNames) = [Either (TargetProblem Void) PackageName]
-> ([TargetProblem Void], [PackageName])
forall a b. [Either a b] -> ([a], [b])
partitionEithers ([Either (TargetProblem Void) PackageName]
-> ([TargetProblem Void], [PackageName]))
-> ((TargetProblem Void -> Either (TargetProblem Void) PackageName)
-> [Either (TargetProblem Void) PackageName])
-> (TargetProblem Void -> Either (TargetProblem Void) PackageName)
-> ([TargetProblem Void], [PackageName])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((TargetProblem Void -> Either (TargetProblem Void) PackageName)
-> [TargetProblem Void]
-> [Either (TargetProblem Void) PackageName])
-> [TargetProblem Void]
-> (TargetProblem Void -> Either (TargetProblem Void) PackageName)
-> [Either (TargetProblem Void) PackageName]
forall a b c. (a -> b -> c) -> b -> a -> c
flip (TargetProblem Void -> Either (TargetProblem Void) PackageName)
-> [TargetProblem Void]
-> [Either (TargetProblem Void) PackageName]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [TargetProblem Void]
errs ((TargetProblem Void -> Either (TargetProblem Void) PackageName)
-> ([TargetProblem Void], [PackageName]))
-> (TargetProblem Void -> Either (TargetProblem Void) PackageName)
-> ([TargetProblem Void], [PackageName])
forall a b. (a -> b) -> a -> b
$ \case
TargetAvailableInIndex PackageName
name -> PackageName -> Either (TargetProblem Void) PackageName
forall a b. b -> Either a b
Right PackageName
name
TargetProblem Void
err -> TargetProblem Void -> Either (TargetProblem Void) PackageName
forall a b. a -> Either a b
Left TargetProblem Void
err
[TargetProblem Void] -> (TargetProblem Void -> IO ()) -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [TargetProblem Void]
errs' ((TargetProblem Void -> IO ()) -> IO ())
-> (TargetProblem Void -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \case
TargetNotInProject PackageName
hn ->
case PackageIndex (SourcePackage UnresolvedPkgLoc)
-> [Char] -> [(PackageName, [SourcePackage UnresolvedPkgLoc])]
forall pkg. PackageIndex pkg -> [Char] -> [(PackageName, [pkg])]
searchByName (SourcePackageDb -> PackageIndex (SourcePackage UnresolvedPkgLoc)
packageIndex SourcePackageDb
pkgDb) (PackageName -> [Char]
unPackageName PackageName
hn) of
[] -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
[(PackageName, [SourcePackage UnresolvedPkgLoc])]
xs ->
Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity (CabalInstallException -> IO ()) -> CabalInstallException -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]] -> CabalInstallException
UnknownPackage (PackageName -> [Char]
unPackageName PackageName
hn) (([Char]
"- " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++) ([Char] -> [Char])
-> ((PackageName, [SourcePackage UnresolvedPkgLoc]) -> [Char])
-> (PackageName, [SourcePackage UnresolvedPkgLoc])
-> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageName -> [Char]
unPackageName (PackageName -> [Char])
-> ((PackageName, [SourcePackage UnresolvedPkgLoc]) -> PackageName)
-> (PackageName, [SourcePackage UnresolvedPkgLoc])
-> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PackageName, [SourcePackage UnresolvedPkgLoc]) -> PackageName
forall a b. (a, b) -> a
fst ((PackageName, [SourcePackage UnresolvedPkgLoc]) -> [Char])
-> [(PackageName, [SourcePackage UnresolvedPkgLoc])] -> [[Char]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(PackageName, [SourcePackage UnresolvedPkgLoc])]
xs)
TargetProblem Void
_ -> () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not (Bool -> Bool)
-> ([TargetProblem Void] -> Bool) -> [TargetProblem Void] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [TargetProblem Void] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([TargetProblem Void] -> Bool) -> [TargetProblem Void] -> Bool
forall a b. (a -> b) -> a -> b
$ [TargetProblem Void]
errs') (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ Verbosity -> [TargetProblem Void] -> IO ()
forall a. Verbosity -> [TargetProblem Void] -> IO a
reportBuildTargetProblems Verbosity
verbosity [TargetProblem Void]
errs'
let
targetSelectors' :: [TargetSelector]
targetSelectors' = ((TargetSelector -> Bool) -> [TargetSelector] -> [TargetSelector])
-> [TargetSelector] -> (TargetSelector -> Bool) -> [TargetSelector]
forall a b c. (a -> b -> c) -> b -> a -> c
flip (TargetSelector -> Bool) -> [TargetSelector] -> [TargetSelector]
forall a. (a -> Bool) -> [a] -> [a]
filter [TargetSelector]
targetSelectors ((TargetSelector -> Bool) -> [TargetSelector])
-> (TargetSelector -> Bool) -> [TargetSelector]
forall a b. (a -> b) -> a -> b
$ \case
TargetComponentUnknown PackageName
name Either UnqualComponentName ComponentName
_ SubComponentTarget
_
| PackageName
name PackageName -> [PackageName] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [PackageName]
hackageNames -> Bool
False
TargetPackageNamed PackageName
name Maybe ComponentKindFilter
_
| PackageName
name PackageName -> [PackageName] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [PackageName]
hackageNames -> Bool
False
TargetSelector
_ -> Bool
True
targets <-
([TargetProblem Void] -> IO TargetsMap)
-> (TargetsMap -> IO TargetsMap)
-> Either [TargetProblem Void] TargetsMap
-> IO TargetsMap
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Verbosity -> [TargetProblem Void] -> IO TargetsMap
forall a. Verbosity -> [TargetProblem Void] -> IO a
reportBuildTargetProblems Verbosity
verbosity) TargetsMap -> IO TargetsMap
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either [TargetProblem Void] TargetsMap -> IO TargetsMap)
-> Either [TargetProblem Void] TargetsMap -> IO TargetsMap
forall a b. (a -> b) -> a -> b
$
(forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem Void) [k])
-> (forall k.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem Void) k)
-> ElaboratedInstallPlan
-> Maybe SourcePackageDb
-> [TargetSelector]
-> Either [TargetProblem Void] TargetsMap
forall err.
(forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem err) [k])
-> (forall k.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem err) k)
-> ElaboratedInstallPlan
-> Maybe SourcePackageDb
-> [TargetSelector]
-> Either [TargetProblem err] TargetsMap
resolveTargetsFromSolver
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem Void) [k]
forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem Void) [k]
selectPackageTargets
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem Void) k
forall k.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem Void) k
selectComponentTarget
ElaboratedInstallPlan
elaboratedPlan
Maybe SourcePackageDb
forall a. Maybe a
Nothing
[TargetSelector]
targetSelectors'
return (targets, hackageNames)
constructProjectBuildContext
:: Verbosity
-> ProjectBaseContext
-> [TargetSelector]
-> IO ProjectBuildContext
constructProjectBuildContext :: Verbosity
-> ProjectBaseContext -> [TargetSelector] -> IO ProjectBuildContext
constructProjectBuildContext Verbosity
verbosity ProjectBaseContext
baseCtx [TargetSelector]
targetSelectors = do
Verbosity
-> ProjectBaseContext
-> (ElaboratedInstallPlan
-> IO (ElaboratedInstallPlan, TargetsMap))
-> IO ProjectBuildContext
runProjectPreBuildPhase Verbosity
verbosity ProjectBaseContext
baseCtx ((ElaboratedInstallPlan -> IO (ElaboratedInstallPlan, TargetsMap))
-> IO ProjectBuildContext)
-> (ElaboratedInstallPlan
-> IO (ElaboratedInstallPlan, TargetsMap))
-> IO ProjectBuildContext
forall a b. (a -> b) -> a -> b
$ \ElaboratedInstallPlan
elaboratedPlan -> do
targets <-
([TargetProblem Void] -> IO TargetsMap)
-> (TargetsMap -> IO TargetsMap)
-> Either [TargetProblem Void] TargetsMap
-> IO TargetsMap
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Verbosity -> [TargetProblem Void] -> IO TargetsMap
forall a. Verbosity -> [TargetProblem Void] -> IO a
reportBuildTargetProblems Verbosity
verbosity) TargetsMap -> IO TargetsMap
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either [TargetProblem Void] TargetsMap -> IO TargetsMap)
-> Either [TargetProblem Void] TargetsMap -> IO TargetsMap
forall a b. (a -> b) -> a -> b
$
(forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem Void) [k])
-> (forall k.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem Void) k)
-> ElaboratedInstallPlan
-> Maybe SourcePackageDb
-> [TargetSelector]
-> Either [TargetProblem Void] TargetsMap
forall err.
(forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem err) [k])
-> (forall k.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem err) k)
-> ElaboratedInstallPlan
-> Maybe SourcePackageDb
-> [TargetSelector]
-> Either [TargetProblem err] TargetsMap
resolveTargetsFromSolver
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem Void) [k]
forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem Void) [k]
selectPackageTargets
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem Void) k
forall k.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem Void) k
selectComponentTarget
ElaboratedInstallPlan
elaboratedPlan
Maybe SourcePackageDb
forall a. Maybe a
Nothing
[TargetSelector]
targetSelectors
let prunedToTargetsElaboratedPlan =
TargetAction
-> TargetsMap -> ElaboratedInstallPlan -> ElaboratedInstallPlan
pruneInstallPlanToTargets TargetAction
TargetActionBuild TargetsMap
targets ElaboratedInstallPlan
elaboratedPlan
prunedElaboratedPlan <-
if buildSettingOnlyDeps (buildSettings baseCtx)
then
either (reportCannotPruneDependencies verbosity) return $
pruneInstallPlanToDependencies
(Map.keysSet targets)
prunedToTargetsElaboratedPlan
else return prunedToTargetsElaboratedPlan
return (prunedElaboratedPlan, targets)
prepareExeInstall :: InstallCfg -> IO InstallExe
prepareExeInstall :: InstallCfg -> IO InstallExe
prepareExeInstall
InstallCfg{Verbosity
verbosity :: InstallCfg -> Verbosity
verbosity :: Verbosity
verbosity, ProjectBaseContext
baseCtx :: InstallCfg -> ProjectBaseContext
baseCtx :: ProjectBaseContext
baseCtx, ProjectBuildContext
buildCtx :: InstallCfg -> ProjectBuildContext
buildCtx :: ProjectBuildContext
buildCtx, Platform
platform :: InstallCfg -> Platform
platform :: Platform
platform, Compiler
compiler :: InstallCfg -> Compiler
compiler :: Compiler
compiler, ConfigFlags
installConfigFlags :: InstallCfg -> ConfigFlags
installConfigFlags :: ConfigFlags
installConfigFlags, ClientInstallFlags
installClientFlags :: InstallCfg -> ClientInstallFlags
installClientFlags :: ClientInstallFlags
installClientFlags} = do
installPath <- IO [Char]
defaultInstallPath
let storeDirLayout = CabalDirLayout -> StoreDirLayout
cabalStoreDirLayout (CabalDirLayout -> StoreDirLayout)
-> CabalDirLayout -> StoreDirLayout
forall a b. (a -> b) -> a -> b
$ ProjectBaseContext -> CabalDirLayout
cabalDirLayout ProjectBaseContext
baseCtx
prefix = [Char] -> Flag [Char] -> [Char]
forall a. a -> Flag a -> a
fromFlagOrDefault [Char]
"" ((PathTemplate -> [Char]) -> Flag PathTemplate -> Flag [Char]
forall a b. (a -> b) -> Last a -> Last b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PathTemplate -> [Char]
InstallDirs.fromPathTemplate (ConfigFlags -> Flag PathTemplate
configProgPrefix ConfigFlags
installConfigFlags))
suffix = [Char] -> Flag [Char] -> [Char]
forall a. a -> Flag a -> a
fromFlagOrDefault [Char]
"" ((PathTemplate -> [Char]) -> Flag PathTemplate -> Flag [Char]
forall a b. (a -> b) -> Last a -> Last b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PathTemplate -> [Char]
InstallDirs.fromPathTemplate (ConfigFlags -> Flag PathTemplate
configProgSuffix ConfigFlags
installConfigFlags))
mkUnitBinDir :: UnitId -> FilePath
mkUnitBinDir =
InstallDirs [Char] -> [Char]
forall dir. InstallDirs dir -> dir
InstallDirs.bindir
(InstallDirs [Char] -> [Char])
-> (UnitId -> InstallDirs [Char]) -> UnitId -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StoreDirLayout -> Compiler -> UnitId -> InstallDirs [Char]
storePackageInstallDirs' StoreDirLayout
storeDirLayout Compiler
compiler
mkExeName :: UnqualComponentName -> FilePath
mkExeName UnqualComponentName
exe = UnqualComponentName -> [Char]
unUnqualComponentName UnqualComponentName
exe [Char] -> [Char] -> [Char]
<.> Platform -> [Char]
exeExtension Platform
platform
mkFinalExeName :: UnqualComponentName -> FilePath
mkFinalExeName UnqualComponentName
exe = [Char]
prefix [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> UnqualComponentName -> [Char]
unUnqualComponentName UnqualComponentName
exe [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
suffix [Char] -> [Char] -> [Char]
<.> Platform -> [Char]
exeExtension Platform
platform
installdirUnknown =
[Char]
"installdir is not defined. Set it in your cabal config file "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"or use --installdir=<path>. Using default installdir: "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
installPath
installdir <-
fromFlagOrDefault
(warn verbosity installdirUnknown >> pure installPath)
$ pure <$> cinstInstalldir installClientFlags
createDirectoryIfMissingVerbose verbosity True installdir
warnIfNoExes verbosity buildCtx
let defaultMethod :: IO InstallMethod
defaultMethod
| OS
buildOS OS -> OS -> Bool
forall a. Eq a => a -> a -> Bool
== OS
Windows = do
symlinks <- Verbosity -> IO Bool
trySymlink Verbosity
verbosity
return $ if symlinks then InstallMethodSymlink else InstallMethodCopy
| Bool
otherwise = InstallMethod -> IO InstallMethod
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InstallMethod
InstallMethodSymlink
installMethod <- flagElim defaultMethod return $ cinstInstallMethod installClientFlags
return $ InstallExe installMethod installdir mkUnitBinDir mkExeName mkFinalExeName
installLibraries
:: Verbosity
-> ProjectBuildContext
-> PI.PackageIndex InstalledPackageInfo
-> Compiler
-> PackageDBStackCWD
-> FilePath
-> [GhcEnvironmentFileEntry FilePath]
-> Bool
-> IO ()
installLibraries :: Verbosity
-> ProjectBuildContext
-> InstalledPackageIndex
-> Compiler
-> PackageDBStackCWD
-> [Char]
-> [GhcEnvironmentFileEntry [Char]]
-> Bool
-> IO ()
installLibraries
Verbosity
verbosity
ProjectBuildContext
buildCtx
InstalledPackageIndex
installedIndex
Compiler
compiler
PackageDBStackCWD
packageDbs'
[Char]
envFile
[GhcEnvironmentFileEntry [Char]]
envEntries
Bool
showWarning = do
if GhcImplInfo -> Bool
supportsPkgEnvFiles (GhcImplInfo -> Bool) -> GhcImplInfo -> Bool
forall a b. (a -> b) -> a -> b
$ Compiler -> GhcImplInfo
getImplInfo Compiler
compiler
then do
let validDb :: PackageDBCWD -> IO Bool
validDb (SpecificPackageDB [Char]
fp) = [Char] -> IO Bool
doesPathExist [Char]
fp
validDb PackageDBCWD
_ = Bool -> IO Bool
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
packageDbs <- (PackageDBCWD -> IO Bool)
-> PackageDBStackCWD -> IO PackageDBStackCWD
forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM PackageDBCWD -> IO Bool
validDb PackageDBStackCWD
packageDbs'
let
getLatest =
((Version, [InstalledPackageInfo]) -> [InstalledPackageInfo])
-> [(Version, [InstalledPackageInfo])] -> [InstalledPackageInfo]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
(=<<) (Maybe InstalledPackageInfo -> [InstalledPackageInfo]
forall a. Maybe a -> [a]
maybeToList (Maybe InstalledPackageInfo -> [InstalledPackageInfo])
-> ((Version, [InstalledPackageInfo])
-> Maybe InstalledPackageInfo)
-> (Version, [InstalledPackageInfo])
-> [InstalledPackageInfo]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [InstalledPackageInfo] -> Maybe InstalledPackageInfo
forall a. [a] -> Maybe a
safeHead ([InstalledPackageInfo] -> Maybe InstalledPackageInfo)
-> ((Version, [InstalledPackageInfo]) -> [InstalledPackageInfo])
-> (Version, [InstalledPackageInfo])
-> Maybe InstalledPackageInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Version, [InstalledPackageInfo]) -> [InstalledPackageInfo]
forall a b. (a, b) -> b
snd)
([(Version, [InstalledPackageInfo])] -> [InstalledPackageInfo])
-> (PackageName -> [(Version, [InstalledPackageInfo])])
-> PackageName
-> [InstalledPackageInfo]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int
-> [(Version, [InstalledPackageInfo])]
-> [(Version, [InstalledPackageInfo])]
forall a. Int -> [a] -> [a]
take Int
1
([(Version, [InstalledPackageInfo])]
-> [(Version, [InstalledPackageInfo])])
-> (PackageName -> [(Version, [InstalledPackageInfo])])
-> PackageName
-> [(Version, [InstalledPackageInfo])]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Version, [InstalledPackageInfo])
-> (Version, [InstalledPackageInfo]) -> Ordering)
-> [(Version, [InstalledPackageInfo])]
-> [(Version, [InstalledPackageInfo])]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (((Version, [InstalledPackageInfo]) -> Down Version)
-> (Version, [InstalledPackageInfo])
-> (Version, [InstalledPackageInfo])
-> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing (Version -> Down Version
forall a. a -> Down a
Down (Version -> Down Version)
-> ((Version, [InstalledPackageInfo]) -> Version)
-> (Version, [InstalledPackageInfo])
-> Down Version
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Version, [InstalledPackageInfo]) -> Version
forall a b. (a, b) -> a
fst))
([(Version, [InstalledPackageInfo])]
-> [(Version, [InstalledPackageInfo])])
-> (PackageName -> [(Version, [InstalledPackageInfo])])
-> PackageName
-> [(Version, [InstalledPackageInfo])]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InstalledPackageIndex
-> PackageName -> [(Version, [InstalledPackageInfo])]
forall a. PackageIndex a -> PackageName -> [(Version, [a])]
PI.lookupPackageName InstalledPackageIndex
installedIndex
globalLatest = [[InstalledPackageInfo]] -> [InstalledPackageInfo]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (PackageName -> [InstalledPackageInfo]
getLatest (PackageName -> [InstalledPackageInfo])
-> [PackageName] -> [[InstalledPackageInfo]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [PackageName]
globalPackages)
globalEntries = UnitId -> GhcEnvironmentFileEntry fp
forall fp. UnitId -> GhcEnvironmentFileEntry fp
GhcEnvFilePackageId (UnitId -> GhcEnvironmentFileEntry fp)
-> (InstalledPackageInfo -> UnitId)
-> InstalledPackageInfo
-> GhcEnvironmentFileEntry fp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InstalledPackageInfo -> UnitId
installedUnitId (InstalledPackageInfo -> GhcEnvironmentFileEntry fp)
-> [InstalledPackageInfo] -> [GhcEnvironmentFileEntry fp]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [InstalledPackageInfo]
globalLatest
baseEntries =
GhcEnvironmentFileEntry [Char]
forall fp. GhcEnvironmentFileEntry fp
GhcEnvFileClearPackageDbStack GhcEnvironmentFileEntry [Char]
-> [GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]]
forall a. a -> [a] -> [a]
: (PackageDBCWD -> GhcEnvironmentFileEntry [Char])
-> PackageDBStackCWD -> [GhcEnvironmentFileEntry [Char]]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PackageDBCWD -> GhcEnvironmentFileEntry [Char]
forall fp. PackageDBX fp -> GhcEnvironmentFileEntry fp
GhcEnvFilePackageDb PackageDBStackCWD
packageDbs
pkgEntries =
[GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]]
forall a. Ord a => [a] -> [a]
ordNub ([GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]])
-> [GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]]
forall a b. (a -> b) -> a -> b
$
[GhcEnvironmentFileEntry [Char]]
forall {fp}. [GhcEnvironmentFileEntry fp]
globalEntries
[GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]]
forall a. [a] -> [a] -> [a]
++ [GhcEnvironmentFileEntry [Char]]
envEntries
[GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]]
forall a. [a] -> [a] -> [a]
++ TargetsMap -> [GhcEnvironmentFileEntry [Char]]
entriesForLibraryComponents (ProjectBuildContext -> TargetsMap
targetsMap ProjectBuildContext
buildCtx)
contents' = [GhcEnvironmentFileEntry [Char]] -> [Char]
renderGhcEnvironmentFile ([GhcEnvironmentFileEntry [Char]]
baseEntries [GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]]
forall a. [a] -> [a] -> [a]
++ [GhcEnvironmentFileEntry [Char]]
pkgEntries)
createDirectoryIfMissing True (takeDirectory envFile)
writeFileAtomic envFile (BS.pack contents')
when showWarning $
warn verbosity $
"The libraries were installed by creating a global GHC environment file at:\n"
++ envFile
++ "\n"
++ "\n"
++ "The presence of such an environment file is likely to confuse or break other "
++ "tools because it changes GHC's behaviour: it changes the default package set in "
++ "ghc and ghci from its normal value (which is \"all boot libraries\"). GHC "
++ "environment files are little-used and often not tested for.\n"
++ "\n"
++ "Furthermore, management of these environment files is still more difficult than "
++ "it could be; see e.g. https://github.com/haskell/cabal/issues/6481 .\n"
++ "\n"
++ "Double-check that creating a global GHC environment file is really what you "
++ "wanted! You can limit the effects of the environment file by creating it in a "
++ "specific directory using the --package-env flag. For example, use:\n"
++ "\n"
++ "cabal install --lib <packages...> --package-env .\n"
++ "\n"
++ "to create the file in the current directory."
else
Verbosity -> [Char] -> IO ()
warn Verbosity
verbosity ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$
[Char]
"The current compiler doesn't support safely installing libraries, "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"so only executables will be available. (Library installation is "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"supported on GHC 8.0+ only)"
globalPackages :: [PackageName]
globalPackages :: [PackageName]
globalPackages = [Char] -> PackageName
mkPackageName ([Char] -> PackageName) -> [[Char]] -> [PackageName]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[Char]
"base"]
warnIfNoExes :: Verbosity -> ProjectBuildContext -> IO ()
warnIfNoExes :: Verbosity -> ProjectBuildContext -> IO ()
warnIfNoExes Verbosity
verbosity ProjectBuildContext
buildCtx =
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
noExes (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
Verbosity -> [Char] -> IO ()
warn Verbosity
verbosity ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$
[Char]
"\n"
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"@ WARNING: Installation might not be completed as desired! @\n"
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n"
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"The command \"cabal install [TARGETS]\" doesn't expose libraries.\n"
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"* You might have wanted to add them as dependencies to your package."
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
" In this case add \""
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
", " (TargetSelector -> [Char]
showTargetSelector (TargetSelector -> [Char]) -> [TargetSelector] -> [[Char]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [TargetSelector]
selectors)
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"\" to the build-depends field(s) of your package's .cabal file.\n"
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"* You might have wanted to add them to a GHC environment. In this case"
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
" use \"cabal install --lib "
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [[Char]] -> [Char]
unwords (TargetSelector -> [Char]
showTargetSelector (TargetSelector -> [Char]) -> [TargetSelector] -> [[Char]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [TargetSelector]
selectors)
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"\". "
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
" The \"--lib\" flag is provisional: see"
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
" https://github.com/haskell/cabal/issues/6481 for more information."
where
targets :: [(ComponentTarget, NonEmpty TargetSelector)]
targets = [[(ComponentTarget, NonEmpty TargetSelector)]]
-> [(ComponentTarget, NonEmpty TargetSelector)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(ComponentTarget, NonEmpty TargetSelector)]]
-> [(ComponentTarget, NonEmpty TargetSelector)])
-> [[(ComponentTarget, NonEmpty TargetSelector)]]
-> [(ComponentTarget, NonEmpty TargetSelector)]
forall a b. (a -> b) -> a -> b
$ TargetsMap -> [[(ComponentTarget, NonEmpty TargetSelector)]]
forall k a. Map k a -> [a]
Map.elems (TargetsMap -> [[(ComponentTarget, NonEmpty TargetSelector)]])
-> TargetsMap -> [[(ComponentTarget, NonEmpty TargetSelector)]]
forall a b. (a -> b) -> a -> b
$ ProjectBuildContext -> TargetsMap
targetsMap ProjectBuildContext
buildCtx
components :: [ComponentTarget]
components = (ComponentTarget, NonEmpty TargetSelector) -> ComponentTarget
forall a b. (a, b) -> a
fst ((ComponentTarget, NonEmpty TargetSelector) -> ComponentTarget)
-> [(ComponentTarget, NonEmpty TargetSelector)]
-> [ComponentTarget]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(ComponentTarget, NonEmpty TargetSelector)]
targets
selectors :: [TargetSelector]
selectors = ((ComponentTarget, NonEmpty TargetSelector) -> [TargetSelector])
-> [(ComponentTarget, NonEmpty TargetSelector)] -> [TargetSelector]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (NonEmpty TargetSelector -> [TargetSelector]
forall a. NonEmpty a -> [a]
NE.toList (NonEmpty TargetSelector -> [TargetSelector])
-> ((ComponentTarget, NonEmpty TargetSelector)
-> NonEmpty TargetSelector)
-> (ComponentTarget, NonEmpty TargetSelector)
-> [TargetSelector]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ComponentTarget, NonEmpty TargetSelector)
-> NonEmpty TargetSelector
forall a b. (a, b) -> b
snd) [(ComponentTarget, NonEmpty TargetSelector)]
targets
noExes :: Bool
noExes = [UnqualComponentName] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([UnqualComponentName] -> Bool) -> [UnqualComponentName] -> Bool
forall a b. (a -> b) -> a -> b
$ [Maybe UnqualComponentName] -> [UnqualComponentName]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe UnqualComponentName] -> [UnqualComponentName])
-> [Maybe UnqualComponentName] -> [UnqualComponentName]
forall a b. (a -> b) -> a -> b
$ ComponentTarget -> Maybe UnqualComponentName
exeMaybe (ComponentTarget -> Maybe UnqualComponentName)
-> [ComponentTarget] -> [Maybe UnqualComponentName]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ComponentTarget]
components
exeMaybe :: ComponentTarget -> Maybe UnqualComponentName
exeMaybe (ComponentTarget (CExeName UnqualComponentName
exe) SubComponentTarget
_) = UnqualComponentName -> Maybe UnqualComponentName
forall a. a -> Maybe a
Just UnqualComponentName
exe
exeMaybe ComponentTarget
_ = Maybe UnqualComponentName
forall a. Maybe a
Nothing
getEnvSpecsAndNonGlobalEntries
:: PI.InstalledPackageIndex
-> [GhcEnvironmentFileEntry FilePath]
-> Bool
-> ([PackageSpecifier a], [(PackageName, GhcEnvironmentFileEntry FilePath)])
getEnvSpecsAndNonGlobalEntries :: forall a.
InstalledPackageIndex
-> [GhcEnvironmentFileEntry [Char]]
-> Bool
-> ([PackageSpecifier a],
[(PackageName, GhcEnvironmentFileEntry [Char])])
getEnvSpecsAndNonGlobalEntries InstalledPackageIndex
installedIndex [GhcEnvironmentFileEntry [Char]]
entries Bool
installLibs =
if Bool
installLibs
then ([PackageSpecifier a]
forall {a}. [PackageSpecifier a]
envSpecs, [(PackageName, GhcEnvironmentFileEntry [Char])]
envEntries')
else ([], [(PackageName, GhcEnvironmentFileEntry [Char])]
envEntries')
where
([PackageSpecifier a]
envSpecs, [(PackageName, GhcEnvironmentFileEntry [Char])]
envEntries') = InstalledPackageIndex
-> [GhcEnvironmentFileEntry [Char]]
-> ([PackageSpecifier a],
[(PackageName, GhcEnvironmentFileEntry [Char])])
forall a.
InstalledPackageIndex
-> [GhcEnvironmentFileEntry [Char]]
-> ([PackageSpecifier a],
[(PackageName, GhcEnvironmentFileEntry [Char])])
environmentFileToSpecifiers InstalledPackageIndex
installedIndex [GhcEnvironmentFileEntry [Char]]
entries
environmentFileToSpecifiers
:: PI.InstalledPackageIndex
-> [GhcEnvironmentFileEntry FilePath]
-> ([PackageSpecifier a], [(PackageName, GhcEnvironmentFileEntry FilePath)])
environmentFileToSpecifiers :: forall a.
InstalledPackageIndex
-> [GhcEnvironmentFileEntry [Char]]
-> ([PackageSpecifier a],
[(PackageName, GhcEnvironmentFileEntry [Char])])
environmentFileToSpecifiers InstalledPackageIndex
ipi = (GhcEnvironmentFileEntry [Char]
-> ([PackageSpecifier a],
[(PackageName, GhcEnvironmentFileEntry [Char])]))
-> [GhcEnvironmentFileEntry [Char]]
-> ([PackageSpecifier a],
[(PackageName, GhcEnvironmentFileEntry [Char])])
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap ((GhcEnvironmentFileEntry [Char]
-> ([PackageSpecifier a],
[(PackageName, GhcEnvironmentFileEntry [Char])]))
-> [GhcEnvironmentFileEntry [Char]]
-> ([PackageSpecifier a],
[(PackageName, GhcEnvironmentFileEntry [Char])]))
-> (GhcEnvironmentFileEntry [Char]
-> ([PackageSpecifier a],
[(PackageName, GhcEnvironmentFileEntry [Char])]))
-> [GhcEnvironmentFileEntry [Char]]
-> ([PackageSpecifier a],
[(PackageName, GhcEnvironmentFileEntry [Char])])
forall a b. (a -> b) -> a -> b
$ \case
(GhcEnvFilePackageId UnitId
unitId)
| Just
InstalledPackageInfo
{ sourcePackageId :: InstalledPackageInfo -> PackageIdentifier
sourcePackageId = PackageIdentifier{Version
PackageName
pkgVersion :: PackageIdentifier -> Version
pkgName :: PackageIdentifier -> PackageName
pkgName :: PackageName
pkgVersion :: Version
..}
, UnitId
installedUnitId :: InstalledPackageInfo -> UnitId
installedUnitId :: UnitId
installedUnitId
} <-
InstalledPackageIndex -> UnitId -> Maybe InstalledPackageInfo
forall a. PackageIndex a -> UnitId -> Maybe a
PI.lookupUnitId InstalledPackageIndex
ipi UnitId
unitId
, let pkgSpec :: PackageSpecifier pkg
pkgSpec =
PackageName -> [PackageProperty] -> PackageSpecifier pkg
forall pkg.
PackageName -> [PackageProperty] -> PackageSpecifier pkg
NamedPackage
PackageName
pkgName
[VersionRange -> PackageProperty
PackagePropertyVersion (Version -> VersionRange
thisVersion Version
pkgVersion)] ->
([PackageSpecifier a
forall {pkg}. PackageSpecifier pkg
pkgSpec], [(PackageName
pkgName, UnitId -> GhcEnvironmentFileEntry [Char]
forall fp. UnitId -> GhcEnvironmentFileEntry fp
GhcEnvFilePackageId UnitId
installedUnitId)])
GhcEnvironmentFileEntry [Char]
_ -> ([], [])
disableTestsBenchsByDefault :: ConfigFlags -> ConfigFlags
disableTestsBenchsByDefault :: ConfigFlags -> ConfigFlags
disableTestsBenchsByDefault ConfigFlags
configFlags =
ConfigFlags
configFlags
{ configTests = Flag False <> configTests configFlags
, configBenchmarks = Flag False <> configBenchmarks configFlags
}
ignoreProgramAffixes :: ConfigFlags -> ConfigFlags
ignoreProgramAffixes :: ConfigFlags -> ConfigFlags
ignoreProgramAffixes ConfigFlags
configFlags =
ConfigFlags
configFlags
{ configProgPrefix = NoFlag
, configProgSuffix = NoFlag
}
symlink :: OverwritePolicy -> InstallExe -> UnitId -> UnqualComponentName -> Symlink
symlink :: OverwritePolicy
-> InstallExe -> UnitId -> UnqualComponentName -> Symlink
symlink
OverwritePolicy
overwritePolicy
InstallExe{[Char]
installDir :: InstallExe -> [Char]
installDir :: [Char]
installDir, UnitId -> [Char]
mkSourceBinDir :: InstallExe -> UnitId -> [Char]
mkSourceBinDir :: UnitId -> [Char]
mkSourceBinDir, UnqualComponentName -> [Char]
mkExeName :: InstallExe -> UnqualComponentName -> [Char]
mkExeName :: UnqualComponentName -> [Char]
mkExeName, UnqualComponentName -> [Char]
mkFinalExeName :: InstallExe -> UnqualComponentName -> [Char]
mkFinalExeName :: UnqualComponentName -> [Char]
mkFinalExeName}
UnitId
unit
UnqualComponentName
exe =
OverwritePolicy -> [Char] -> [Char] -> [Char] -> [Char] -> Symlink
Symlink
OverwritePolicy
overwritePolicy
[Char]
installDir
(UnitId -> [Char]
mkSourceBinDir UnitId
unit)
(UnqualComponentName -> [Char]
mkFinalExeName UnqualComponentName
exe)
(UnqualComponentName -> [Char]
mkExeName UnqualComponentName
exe)
installCheckUnitExes :: InstallCheck -> InstallAction
installCheckUnitExes :: InstallCheck -> InstallAction
installCheckUnitExes
InstallCheck
installCheck
Verbosity
verbosity
OverwritePolicy
overwritePolicy
installExe :: InstallExe
installExe@InstallExe{InstallMethod
installMethod :: InstallExe -> InstallMethod
installMethod :: InstallMethod
installMethod, [Char]
installDir :: InstallExe -> [Char]
installDir :: [Char]
installDir, UnitId -> [Char]
mkSourceBinDir :: InstallExe -> UnitId -> [Char]
mkSourceBinDir :: UnitId -> [Char]
mkSourceBinDir, UnqualComponentName -> [Char]
mkExeName :: InstallExe -> UnqualComponentName -> [Char]
mkExeName :: UnqualComponentName -> [Char]
mkExeName, UnqualComponentName -> [Char]
mkFinalExeName :: InstallExe -> UnqualComponentName -> [Char]
mkFinalExeName :: UnqualComponentName -> [Char]
mkFinalExeName}
(UnitId
unit, [(ComponentTarget, NonEmpty TargetSelector)]
components) = do
symlinkables :: [Bool] <- (UnqualComponentName -> IO Bool)
-> [UnqualComponentName] -> IO [Bool]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (Symlink -> IO Bool
symlinkableBinary (Symlink -> IO Bool)
-> (UnqualComponentName -> Symlink)
-> UnqualComponentName
-> IO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OverwritePolicy
-> InstallExe -> UnitId -> UnqualComponentName -> Symlink
symlink OverwritePolicy
overwritePolicy InstallExe
installExe UnitId
unit) [UnqualComponentName]
exes
case installCheck of
InstallCheck
InstallCheckOnly -> ((Bool, UnqualComponentName) -> IO ())
-> [(Bool, UnqualComponentName)] -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ (Bool, UnqualComponentName) -> IO ()
warnAbout ([Bool] -> [UnqualComponentName] -> [(Bool, UnqualComponentName)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Bool]
symlinkables [UnqualComponentName]
exes)
InstallCheck
InstallCheckInstall ->
if [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [Bool]
symlinkables
then (UnqualComponentName -> IO ()) -> [UnqualComponentName] -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ UnqualComponentName -> IO ()
installAndWarn [UnqualComponentName]
exes
else ((Bool, UnqualComponentName) -> IO ())
-> [(Bool, UnqualComponentName)] -> IO ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
(a -> f b) -> t a -> f ()
traverse_ (Bool, UnqualComponentName) -> IO ()
warnAbout ([Bool] -> [UnqualComponentName] -> [(Bool, UnqualComponentName)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Bool]
symlinkables [UnqualComponentName]
exes)
where
exes :: [UnqualComponentName]
exes = [Maybe UnqualComponentName] -> [UnqualComponentName]
forall a. [Maybe a] -> [a]
catMaybes ([Maybe UnqualComponentName] -> [UnqualComponentName])
-> [Maybe UnqualComponentName] -> [UnqualComponentName]
forall a b. (a -> b) -> a -> b
$ (ComponentTarget -> Maybe UnqualComponentName
exeMaybe (ComponentTarget -> Maybe UnqualComponentName)
-> ((ComponentTarget, NonEmpty TargetSelector) -> ComponentTarget)
-> (ComponentTarget, NonEmpty TargetSelector)
-> Maybe UnqualComponentName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ComponentTarget, NonEmpty TargetSelector) -> ComponentTarget
forall a b. (a, b) -> a
fst) ((ComponentTarget, NonEmpty TargetSelector)
-> Maybe UnqualComponentName)
-> [(ComponentTarget, NonEmpty TargetSelector)]
-> [Maybe UnqualComponentName]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(ComponentTarget, NonEmpty TargetSelector)]
components
exeMaybe :: ComponentTarget -> Maybe UnqualComponentName
exeMaybe (ComponentTarget (CExeName UnqualComponentName
exe) SubComponentTarget
_) = UnqualComponentName -> Maybe UnqualComponentName
forall a. a -> Maybe a
Just UnqualComponentName
exe
exeMaybe ComponentTarget
_ = Maybe UnqualComponentName
forall a. Maybe a
Nothing
warnAbout :: (Bool, UnqualComponentName) -> IO ()
warnAbout (Bool
True, UnqualComponentName
_) = () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
warnAbout (Bool
False, UnqualComponentName
exe) = Verbosity -> CabalInstallException -> IO ()
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity (CabalInstallException -> IO ()) -> CabalInstallException -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> CabalInstallException
InstallUnitExes ([Char] -> UnqualComponentName -> [Char]
errorMessage [Char]
installDir UnqualComponentName
exe)
installAndWarn :: UnqualComponentName -> IO ()
installAndWarn UnqualComponentName
exe = do
success <-
Verbosity
-> OverwritePolicy
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> InstallMethod
-> IO Bool
installBuiltExe
Verbosity
verbosity
OverwritePolicy
overwritePolicy
(UnitId -> [Char]
mkSourceBinDir UnitId
unit)
(UnqualComponentName -> [Char]
mkExeName UnqualComponentName
exe)
(UnqualComponentName -> [Char]
mkFinalExeName UnqualComponentName
exe)
[Char]
installDir
InstallMethod
installMethod
unless success $ dieWithException verbosity $ InstallUnitExes (errorMessage installDir exe)
errorMessage :: [Char] -> UnqualComponentName -> [Char]
errorMessage [Char]
installdir UnqualComponentName
exe = case OverwritePolicy
overwritePolicy of
OverwritePolicy
NeverOverwrite ->
[Char]
"Path '"
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> ([Char]
installdir [Char] -> [Char] -> [Char]
</> UnqualComponentName -> [Char]
mkFinalExeName UnqualComponentName
exe)
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"' already exists. "
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"Use --overwrite-policy=always to overwrite."
OverwritePolicy
_ ->
case InstallMethod
installMethod of
InstallMethod
InstallMethodSymlink -> [Char]
"Symlinking"
InstallMethod
InstallMethodCopy -> [Char]
"Copying" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
" '" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> UnqualComponentName -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow UnqualComponentName
exe [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"' failed."
installBuiltExe
:: Verbosity
-> OverwritePolicy
-> FilePath
-> FilePath
-> FilePath
-> FilePath
-> InstallMethod
-> IO Bool
installBuiltExe :: Verbosity
-> OverwritePolicy
-> [Char]
-> [Char]
-> [Char]
-> [Char]
-> InstallMethod
-> IO Bool
installBuiltExe
Verbosity
verbosity
OverwritePolicy
overwritePolicy
[Char]
sourceDir
[Char]
exeName
[Char]
finalExeName
[Char]
installdir
InstallMethod
InstallMethodSymlink = do
Verbosity -> [Char] -> IO ()
notice Verbosity
verbosity ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Symlinking '" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
exeName [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"' to '" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
destination [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"'"
Symlink -> IO Bool
symlinkBinary
( OverwritePolicy -> [Char] -> [Char] -> [Char] -> [Char] -> Symlink
Symlink
OverwritePolicy
overwritePolicy
[Char]
installdir
[Char]
sourceDir
[Char]
finalExeName
[Char]
exeName
)
where
destination :: [Char]
destination = [Char]
installdir [Char] -> [Char] -> [Char]
</> [Char]
finalExeName
installBuiltExe
Verbosity
verbosity
OverwritePolicy
overwritePolicy
[Char]
sourceDir
[Char]
exeName
[Char]
finalExeName
[Char]
installdir
InstallMethod
InstallMethodCopy = do
Verbosity -> [Char] -> IO ()
notice Verbosity
verbosity ([Char] -> IO ()) -> [Char] -> IO ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Copying '" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
exeName [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"' to '" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
destination [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"'"
exists <- [Char] -> IO Bool
doesPathExist [Char]
destination
case (exists, overwritePolicy) of
(Bool
True, OverwritePolicy
NeverOverwrite) -> Bool -> IO Bool
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
(Bool
True, OverwritePolicy
AlwaysOverwrite) -> IO Bool
overwrite
(Bool
True, OverwritePolicy
PromptOverwrite) -> IO Bool
maybeOverwrite
(Bool
False, OverwritePolicy
_) -> IO Bool
copy
where
source :: [Char]
source = [Char]
sourceDir [Char] -> [Char] -> [Char]
</> [Char]
exeName
destination :: [Char]
destination = [Char]
installdir [Char] -> [Char] -> [Char]
</> [Char]
finalExeName
remove :: IO ()
remove = do
isDir <- [Char] -> IO Bool
doesDirectoryExist [Char]
destination
if isDir
then removeDirectory destination
else removeFile destination
copy :: IO Bool
copy = [Char] -> [Char] -> IO ()
copyFile [Char]
source [Char]
destination IO () -> IO Bool -> IO Bool
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Bool -> IO Bool
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
overwrite :: IO Bool
overwrite :: IO Bool
overwrite = IO ()
remove IO () -> IO Bool -> IO Bool
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> IO Bool
copy
maybeOverwrite :: IO Bool
maybeOverwrite :: IO Bool
maybeOverwrite =
[Char] -> IO Bool -> IO Bool
promptRun
[Char]
"Existing file found while installing executable. Do you want to overwrite that file? (y/n)"
IO Bool
overwrite
entriesForLibraryComponents :: TargetsMap -> [GhcEnvironmentFileEntry FilePath]
entriesForLibraryComponents :: TargetsMap -> [GhcEnvironmentFileEntry [Char]]
entriesForLibraryComponents = (UnitId
-> [(ComponentTarget, NonEmpty TargetSelector)]
-> [GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]])
-> [GhcEnvironmentFileEntry [Char]]
-> TargetsMap
-> [GhcEnvironmentFileEntry [Char]]
forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
Map.foldrWithKey' (\UnitId
k [(ComponentTarget, NonEmpty TargetSelector)]
v -> [GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]]
-> [GhcEnvironmentFileEntry [Char]]
forall a. Monoid a => a -> a -> a
mappend (UnitId
-> [(ComponentTarget, NonEmpty TargetSelector)]
-> [GhcEnvironmentFileEntry [Char]]
go UnitId
k [(ComponentTarget, NonEmpty TargetSelector)]
v)) []
where
hasLib :: (ComponentTarget, NonEmpty TargetSelector) -> Bool
hasLib :: (ComponentTarget, NonEmpty TargetSelector) -> Bool
hasLib (ComponentTarget (CLibName LibraryName
_) SubComponentTarget
_, NonEmpty TargetSelector
_) = Bool
True
hasLib (ComponentTarget, NonEmpty TargetSelector)
_ = Bool
False
go
:: UnitId
-> [(ComponentTarget, NonEmpty TargetSelector)]
-> [GhcEnvironmentFileEntry FilePath]
go :: UnitId
-> [(ComponentTarget, NonEmpty TargetSelector)]
-> [GhcEnvironmentFileEntry [Char]]
go UnitId
unitId [(ComponentTarget, NonEmpty TargetSelector)]
targets
| ((ComponentTarget, NonEmpty TargetSelector) -> Bool)
-> [(ComponentTarget, NonEmpty TargetSelector)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (ComponentTarget, NonEmpty TargetSelector) -> Bool
hasLib [(ComponentTarget, NonEmpty TargetSelector)]
targets = [UnitId -> GhcEnvironmentFileEntry [Char]
forall fp. UnitId -> GhcEnvironmentFileEntry fp
GhcEnvFilePackageId UnitId
unitId]
| Bool
otherwise = []
getEnvFile :: ClientInstallFlags -> Platform -> Version -> IO (Bool, FilePath)
getEnvFile :: ClientInstallFlags -> Platform -> Version -> IO (Bool, [Char])
getEnvFile ClientInstallFlags
clientInstallFlags Platform
platform Version
compilerVersion = do
appDir <- IO [Char]
getGhcAppDir
case flagToMaybe (cinstEnvironmentPath clientInstallFlags) of
Just [Char]
spec
| [Char] -> [Char]
takeBaseName [Char]
spec [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
spec ->
(Bool, [Char]) -> IO (Bool, [Char])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
True, [Char] -> Platform -> Version -> [Char] -> [Char]
getGlobalEnv [Char]
appDir Platform
platform Version
compilerVersion [Char]
spec)
| Bool
otherwise -> do
spec' <- [Char] -> IO [Char]
makeAbsolute [Char]
spec
isDir <- doesDirectoryExist spec'
if isDir
then
return (True, getLocalEnv spec' platform compilerVersion)
else
return (True, spec')
Maybe [Char]
Nothing ->
(Bool, [Char]) -> IO (Bool, [Char])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
False, [Char] -> Platform -> Version -> [Char] -> [Char]
getGlobalEnv [Char]
appDir Platform
platform Version
compilerVersion [Char]
"default")
getExistingEnvEntries :: Verbosity -> CompilerFlavor -> Bool -> FilePath -> IO (Bool, [GhcEnvironmentFileEntry FilePath])
getExistingEnvEntries :: Verbosity
-> CompilerFlavor
-> Bool
-> [Char]
-> IO (Bool, [GhcEnvironmentFileEntry [Char]])
getExistingEnvEntries Verbosity
verbosity CompilerFlavor
compilerFlavor Bool
supportsPkgEnvFiles [Char]
envFile = do
envFileExists <- [Char] -> IO Bool
doesFileExist [Char]
envFile
(usedExisting, allEntries) <-
if (compilerFlavor == GHC || compilerFlavor == GHCJS)
&& supportsPkgEnvFiles
&& envFileExists
then catch ((True,) <$> readGhcEnvironmentFile envFile) $ \(ParseErrorExc
_ :: ParseErrorExc) ->
Verbosity -> [Char] -> IO ()
warn
Verbosity
verbosity
( [Char]
"The environment file "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
envFile
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" is unparsable. Libraries cannot be installed."
)
IO ()
-> IO (Bool, [GhcEnvironmentFileEntry [Char]])
-> IO (Bool, [GhcEnvironmentFileEntry [Char]])
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Bool, [GhcEnvironmentFileEntry [Char]])
-> IO (Bool, [GhcEnvironmentFileEntry [Char]])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
False, [])
else return (False, [])
return (usedExisting, filterEnvEntries allEntries)
where
filterEnvEntries :: [GhcEnvironmentFileEntry fp] -> [GhcEnvironmentFileEntry fp]
filterEnvEntries = (GhcEnvironmentFileEntry fp -> Bool)
-> [GhcEnvironmentFileEntry fp] -> [GhcEnvironmentFileEntry fp]
forall a. (a -> Bool) -> [a] -> [a]
filter ((GhcEnvironmentFileEntry fp -> Bool)
-> [GhcEnvironmentFileEntry fp] -> [GhcEnvironmentFileEntry fp])
-> (GhcEnvironmentFileEntry fp -> Bool)
-> [GhcEnvironmentFileEntry fp]
-> [GhcEnvironmentFileEntry fp]
forall a b. (a -> b) -> a -> b
$ \case
GhcEnvFilePackageId UnitId
_ -> Bool
True
GhcEnvironmentFileEntry fp
_ -> Bool
False
getGlobalEnv :: FilePath -> Platform -> Version -> String -> FilePath
getGlobalEnv :: [Char] -> Platform -> Version -> [Char] -> [Char]
getGlobalEnv [Char]
appDir Platform
platform Version
compilerVersion [Char]
name =
[Char]
appDir
[Char] -> [Char] -> [Char]
</> Platform -> Version -> [Char]
ghcPlatformAndVersionString Platform
platform Version
compilerVersion
[Char] -> [Char] -> [Char]
</> [Char]
"environments"
[Char] -> [Char] -> [Char]
</> [Char]
name
getLocalEnv :: FilePath -> Platform -> Version -> FilePath
getLocalEnv :: [Char] -> Platform -> Version -> [Char]
getLocalEnv [Char]
dir Platform
platform Version
compilerVersion =
[Char]
dir
[Char] -> [Char] -> [Char]
</> [Char]
".ghc.environment."
[Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Platform -> Version -> [Char]
ghcPlatformAndVersionString Platform
platform Version
compilerVersion
getPackageDbStack
:: Compiler
-> Flag FilePath
-> Flag FilePath
-> [Maybe PackageDBCWD]
-> IO PackageDBStackCWD
getPackageDbStack :: Compiler
-> Flag [Char]
-> Flag [Char]
-> [Maybe PackageDBCWD]
-> IO PackageDBStackCWD
getPackageDbStack Compiler
compiler Flag [Char]
storeDirFlag Flag [Char]
logsDirFlag [Maybe PackageDBCWD]
packageDbs = do
mstoreDir <- ([Char] -> IO [Char]) -> Maybe [Char] -> IO (Maybe [Char])
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse [Char] -> IO [Char]
makeAbsolute (Maybe [Char] -> IO (Maybe [Char]))
-> Maybe [Char] -> IO (Maybe [Char])
forall a b. (a -> b) -> a -> b
$ Flag [Char] -> Maybe [Char]
forall a. Flag a -> Maybe a
flagToMaybe Flag [Char]
storeDirFlag
let
mlogsDir = Flag [Char] -> Maybe [Char]
forall a. Flag a -> Maybe a
flagToMaybe Flag [Char]
logsDirFlag
cabalLayout <- mkCabalDirLayout mstoreDir mlogsDir
pure $ storePackageDBStack (cabalStoreDirLayout cabalLayout) compiler packageDbs
selectPackageTargets
:: TargetSelector
-> [AvailableTarget k]
-> Either TargetProblem' [k]
selectPackageTargets :: forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem Void) [k]
selectPackageTargets TargetSelector
targetSelector [AvailableTarget k]
targets
| Bool -> Bool
not ([k] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [k]
targetsBuildable) =
[k] -> Either (TargetProblem Void) [k]
forall a b. b -> Either a b
Right [k]
targetsBuildable
| Bool -> Bool
not ([AvailableTarget k] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [AvailableTarget k]
targets) =
TargetProblem Void -> Either (TargetProblem Void) [k]
forall a b. a -> Either a b
Left (TargetSelector -> [AvailableTarget ()] -> TargetProblem Void
forall a. TargetSelector -> [AvailableTarget ()] -> TargetProblem a
TargetProblemNoneEnabled TargetSelector
targetSelector [AvailableTarget ()]
targets')
| Bool
otherwise =
TargetProblem Void -> Either (TargetProblem Void) [k]
forall a b. a -> Either a b
Left (TargetSelector -> TargetProblem Void
forall a. TargetSelector -> TargetProblem a
TargetProblemNoTargets TargetSelector
targetSelector)
where
targets' :: [AvailableTarget ()]
targets' = [AvailableTarget k] -> [AvailableTarget ()]
forall k. [AvailableTarget k] -> [AvailableTarget ()]
forgetTargetsDetail [AvailableTarget k]
targets
targetsBuildable :: [k]
targetsBuildable =
(TargetRequested -> Bool) -> [AvailableTarget k] -> [k]
forall k. (TargetRequested -> Bool) -> [AvailableTarget k] -> [k]
selectBuildableTargetsWith
(TargetSelector -> TargetRequested -> Bool
buildable TargetSelector
targetSelector)
[AvailableTarget k]
targets
buildable :: TargetSelector -> TargetRequested -> Bool
buildable (TargetPackage TargetImplicitCwd
_ [PackageIdentifier]
_ Maybe ComponentKindFilter
Nothing) TargetRequested
TargetNotRequestedByDefault = Bool
False
buildable (TargetAllPackages Maybe ComponentKindFilter
Nothing) TargetRequested
TargetNotRequestedByDefault = Bool
False
buildable TargetSelector
_ TargetRequested
_ = Bool
True
selectComponentTarget
:: SubComponentTarget
-> AvailableTarget k
-> Either TargetProblem' k
selectComponentTarget :: forall k.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem Void) k
selectComponentTarget = SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem Void) k
forall k a.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem a) k
selectComponentTargetBasic
reportBuildTargetProblems :: Verbosity -> [TargetProblem'] -> IO a
reportBuildTargetProblems :: forall a. Verbosity -> [TargetProblem Void] -> IO a
reportBuildTargetProblems Verbosity
verbosity [TargetProblem Void]
problems = Verbosity -> [Char] -> [TargetProblem Void] -> IO a
forall a. Verbosity -> [Char] -> [TargetProblem Void] -> IO a
reportTargetProblems Verbosity
verbosity [Char]
"build" [TargetProblem Void]
problems
reportCannotPruneDependencies :: Verbosity -> CannotPruneDependencies -> IO a
reportCannotPruneDependencies :: forall a. Verbosity -> CannotPruneDependencies -> IO a
reportCannotPruneDependencies Verbosity
verbosity =
Verbosity -> CabalInstallException -> IO a
forall a1 a.
(HasCallStack, Show a1, Typeable a1,
Exception (VerboseException a1)) =>
Verbosity -> a1 -> IO a
dieWithException Verbosity
verbosity (CabalInstallException -> IO a)
-> (CannotPruneDependencies -> CabalInstallException)
-> CannotPruneDependencies
-> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> CabalInstallException
SelectComponentTargetError ([Char] -> CabalInstallException)
-> (CannotPruneDependencies -> [Char])
-> CannotPruneDependencies
-> CabalInstallException
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CannotPruneDependencies -> [Char]
renderCannotPruneDependencies