{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TupleSections #-}
module Distribution.Client.CmdRun (
runCommand,
runAction,
handleShebang, validScript,
matchesMultipleProblem,
noExesProblem,
selectPackageTargets,
selectComponentTarget
) where
import Prelude ()
import Distribution.Client.Compat.Prelude hiding (toList)
import Distribution.Client.ProjectOrchestration
import Distribution.Client.CmdErrorMessages
( renderTargetSelector, showTargetSelector,
renderTargetProblem,
renderTargetProblemNoTargets, plural, targetSelectorPluralPkgs,
targetSelectorFilter, renderListCommaAnd )
import Distribution.Client.TargetProblem
( TargetProblem (..) )
import Distribution.Client.NixStyleOptions
( NixStyleFlags (..), nixStyleOptions, defaultNixStyleFlags )
import Distribution.Client.Setup
( GlobalFlags(..), ConfigFlags(..) )
import Distribution.Client.GlobalFlags
( defaultGlobalFlags )
import Distribution.Simple.Flag
( fromFlagOrDefault )
import Distribution.Simple.Command
( CommandUI(..), usageAlternatives )
import Distribution.Types.ComponentName
( showComponentName )
import Distribution.Verbosity
( normal, silent )
import Distribution.Simple.Utils
( wrapText, die', info, notice )
import Distribution.Client.ProjectPlanning
( ElaboratedConfiguredPackage(..)
, ElaboratedInstallPlan, binDirectoryFor )
import Distribution.Client.ProjectPlanning.Types
( dataDirsEnvironmentForPlan )
import Distribution.Client.InstallPlan
( toList, foldPlanPackage )
import Distribution.Types.UnqualComponentName
( UnqualComponentName, unUnqualComponentName )
import Distribution.Simple.Program.Run
( runProgramInvocation, ProgramInvocation(..),
emptyProgramInvocation )
import Distribution.Types.UnitId
( UnitId )
import Distribution.Client.ScriptUtils
( AcceptNoTargets(..), withContextAndSelectors, updateContextAndWriteProjectFile, TargetContext(..) )
import qualified Data.Set as Set
import System.Directory
( doesFileExist )
import System.FilePath
( (</>), isValid, isPathSeparator )
runCommand :: CommandUI (NixStyleFlags ())
runCommand :: CommandUI (NixStyleFlags ())
runCommand = CommandUI :: forall flags.
String
-> String
-> (String -> String)
-> Maybe (String -> String)
-> Maybe (String -> String)
-> flags
-> (ShowOrParseArgs -> [OptionField flags])
-> CommandUI flags
CommandUI
{ commandName :: String
commandName = String
"v2-run"
, commandSynopsis :: String
commandSynopsis = String
"Run an executable."
, commandUsage :: String -> String
commandUsage = String -> [String] -> String -> String
usageAlternatives String
"v2-run"
[ String
"[TARGET] [FLAGS] [-- EXECUTABLE_FLAGS]" ]
, commandDescription :: Maybe (String -> String)
commandDescription = (String -> String) -> Maybe (String -> String)
forall a. a -> Maybe a
Just ((String -> String) -> Maybe (String -> String))
-> (String -> String) -> Maybe (String -> String)
forall a b. (a -> b) -> a -> b
$ \String
pname -> String -> String
wrapText (String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$
String
"Runs the specified executable-like component (an executable, a test, "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"or a benchmark), first ensuring it is up to date.\n\n"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"Any executable-like component in any package in the project can be "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"specified. A package can be specified if contains just one "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"executable-like, preferring a single executable. The default is to "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"use the package in the current directory if it contains just one "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"executable-like.\n\n"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"Extra arguments can be passed to the program, but use '--' to "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"separate arguments for the program from arguments for " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
pname
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
". The executable is run in an environment where it can find its "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"data files inplace in the build tree.\n\n"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"Dependencies are built or rebuilt as necessary. Additional "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"configuration flags can be specified on the command line and these "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"extend the project configuration from the 'cabal.project', "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"'cabal.project.local' and other files."
, commandNotes :: Maybe (String -> String)
commandNotes = (String -> String) -> Maybe (String -> String)
forall a. a -> Maybe a
Just ((String -> String) -> Maybe (String -> String))
-> (String -> String) -> Maybe (String -> String)
forall a b. (a -> b) -> a -> b
$ \String
pname ->
String
"Examples:\n"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
pname String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" v2-run\n"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" Run the executable-like in the package in the current directory\n"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
pname String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" v2-run foo-tool\n"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" Run the named executable-like (in any package in the project)\n"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
pname String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" v2-run pkgfoo:foo-tool\n"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" Run the executable-like 'foo-tool' in the package 'pkgfoo'\n"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
pname String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" v2-run foo -O2 -- dothing --fooflag\n"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" Build with '-O2' and run the program, passing it extra arguments.\n"
, commandDefaultFlags :: NixStyleFlags ()
commandDefaultFlags = () -> NixStyleFlags ()
forall a. a -> NixStyleFlags a
defaultNixStyleFlags ()
, commandOptions :: ShowOrParseArgs -> [OptionField (NixStyleFlags ())]
commandOptions = (ShowOrParseArgs -> [OptionField ()])
-> ShowOrParseArgs -> [OptionField (NixStyleFlags ())]
forall a.
(ShowOrParseArgs -> [OptionField a])
-> ShowOrParseArgs -> [OptionField (NixStyleFlags a)]
nixStyleOptions ([OptionField ()] -> ShowOrParseArgs -> [OptionField ()]
forall a b. a -> b -> a
const [])
}
runAction :: NixStyleFlags () -> [String] -> GlobalFlags -> IO ()
runAction :: NixStyleFlags () -> [String] -> GlobalFlags -> IO ()
runAction flags :: NixStyleFlags ()
flags@NixStyleFlags {()
ConfigFlags
HaddockFlags
TestFlags
BenchmarkFlags
ProjectFlags
InstallFlags
ConfigExFlags
extraFlags :: forall a. NixStyleFlags a -> a
projectFlags :: forall a. NixStyleFlags a -> ProjectFlags
benchmarkFlags :: forall a. NixStyleFlags a -> BenchmarkFlags
testFlags :: forall a. NixStyleFlags a -> TestFlags
haddockFlags :: forall a. NixStyleFlags a -> HaddockFlags
installFlags :: forall a. NixStyleFlags a -> InstallFlags
configExFlags :: forall a. NixStyleFlags a -> ConfigExFlags
configFlags :: forall a. NixStyleFlags a -> ConfigFlags
extraFlags :: ()
projectFlags :: ProjectFlags
benchmarkFlags :: BenchmarkFlags
testFlags :: TestFlags
haddockFlags :: HaddockFlags
installFlags :: InstallFlags
configExFlags :: ConfigExFlags
configFlags :: ConfigFlags
..} [String]
targetAndArgs GlobalFlags
globalFlags
= AcceptNoTargets
-> Maybe ComponentKind
-> NixStyleFlags ()
-> [String]
-> GlobalFlags
-> (TargetContext
-> ProjectBaseContext -> [TargetSelector] -> IO ())
-> IO ()
forall a b.
AcceptNoTargets
-> Maybe ComponentKind
-> NixStyleFlags a
-> [String]
-> GlobalFlags
-> (TargetContext
-> ProjectBaseContext -> [TargetSelector] -> IO b)
-> IO b
withContextAndSelectors AcceptNoTargets
RejectNoTargets (ComponentKind -> Maybe ComponentKind
forall a. a -> Maybe a
Just ComponentKind
ExeKind) NixStyleFlags ()
flags [String]
targetStr GlobalFlags
globalFlags ((TargetContext -> ProjectBaseContext -> [TargetSelector] -> IO ())
-> IO ())
-> (TargetContext
-> ProjectBaseContext -> [TargetSelector] -> IO ())
-> IO ()
forall a b. (a -> b) -> a -> b
$ \TargetContext
targetCtx ProjectBaseContext
ctx [TargetSelector]
targetSelectors -> do
(ProjectBaseContext
baseCtx, Verbosity
defaultVerbosity) <- case TargetContext
targetCtx of
TargetContext
ProjectContext -> (ProjectBaseContext, Verbosity)
-> IO (ProjectBaseContext, Verbosity)
forall (m :: * -> *) a. Monad m => a -> m a
return (ProjectBaseContext
ctx, Verbosity
normal)
TargetContext
GlobalContext -> (ProjectBaseContext, Verbosity)
-> IO (ProjectBaseContext, Verbosity)
forall (m :: * -> *) a. Monad m => a -> m a
return (ProjectBaseContext
ctx, Verbosity
normal)
ScriptContext String
path Executable
exemeta -> (, Verbosity
silent) (ProjectBaseContext -> (ProjectBaseContext, Verbosity))
-> IO ProjectBaseContext -> IO (ProjectBaseContext, Verbosity)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ProjectBaseContext -> String -> Executable -> IO ProjectBaseContext
updateContextAndWriteProjectFile ProjectBaseContext
ctx String
path Executable
exemeta
let verbosity :: Verbosity
verbosity = Verbosity -> Flag Verbosity -> Verbosity
forall a. a -> Flag a -> a
fromFlagOrDefault Verbosity
defaultVerbosity (ConfigFlags -> Flag Verbosity
configVerbosity ConfigFlags
configFlags)
ProjectBuildContext
buildCtx <-
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
Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (BuildTimeSettings -> Bool
buildSettingOnlyDeps (ProjectBaseContext -> BuildTimeSettings
buildSettings ProjectBaseContext
baseCtx)) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
Verbosity -> String -> IO ()
forall a. Verbosity -> String -> IO a
die' Verbosity
verbosity (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$
String
"The run command does not support '--only-dependencies'. "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"You may wish to use 'build --only-dependencies' and then "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"use 'run'."
TargetsMap
targets <- ([RunTargetProblem] -> IO TargetsMap)
-> (TargetsMap -> IO TargetsMap)
-> Either [RunTargetProblem] TargetsMap
-> IO TargetsMap
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Verbosity -> [RunTargetProblem] -> IO TargetsMap
forall a. Verbosity -> [RunTargetProblem] -> IO a
reportTargetProblems Verbosity
verbosity) TargetsMap -> IO TargetsMap
forall (m :: * -> *) a. Monad m => a -> m a
return
(Either [RunTargetProblem] TargetsMap -> IO TargetsMap)
-> Either [RunTargetProblem] TargetsMap -> IO TargetsMap
forall a b. (a -> b) -> a -> b
$ (forall k.
TargetSelector
-> [AvailableTarget k] -> Either RunTargetProblem [k])
-> (forall k.
SubComponentTarget
-> AvailableTarget k -> Either RunTargetProblem k)
-> ElaboratedInstallPlan
-> Maybe SourcePackageDb
-> [TargetSelector]
-> Either [RunTargetProblem] 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
resolveTargets
forall k.
TargetSelector
-> [AvailableTarget k] -> Either RunTargetProblem [k]
selectPackageTargets
forall k.
SubComponentTarget
-> AvailableTarget k -> Either RunTargetProblem k
selectComponentTarget
ElaboratedInstallPlan
elaboratedPlan
Maybe SourcePackageDb
forall a. Maybe a
Nothing
[TargetSelector]
targetSelectors
(UnitId, UnqualComponentName)
_ <- IO (UnitId, UnqualComponentName)
-> TargetsMap -> IO (UnitId, UnqualComponentName)
singleExeOrElse
(Verbosity -> [RunTargetProblem] -> IO (UnitId, UnqualComponentName)
forall a. Verbosity -> [RunTargetProblem] -> IO a
reportTargetProblems
Verbosity
verbosity
[TargetsMap -> RunTargetProblem
multipleTargetsProblem TargetsMap
targets])
TargetsMap
targets
let elaboratedPlan' :: ElaboratedInstallPlan
elaboratedPlan' = TargetAction
-> TargetsMap -> ElaboratedInstallPlan -> ElaboratedInstallPlan
pruneInstallPlanToTargets
TargetAction
TargetActionBuild
TargetsMap
targets
ElaboratedInstallPlan
elaboratedPlan
(ElaboratedInstallPlan, TargetsMap)
-> IO (ElaboratedInstallPlan, TargetsMap)
forall (m :: * -> *) a. Monad m => a -> m a
return (ElaboratedInstallPlan
elaboratedPlan', TargetsMap
targets)
(UnitId
selectedUnitId, UnqualComponentName
selectedComponent) <-
IO (UnitId, UnqualComponentName)
-> TargetsMap -> IO (UnitId, UnqualComponentName)
singleExeOrElse
(Verbosity -> String -> IO (UnitId, UnqualComponentName)
forall a. Verbosity -> String -> IO a
die' Verbosity
verbosity (String -> IO (UnitId, UnqualComponentName))
-> String -> IO (UnitId, UnqualComponentName)
forall a b. (a -> b) -> a -> b
$ String
"No or multiple targets given, but the run "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"phase has been reached. This is a bug.")
(TargetsMap -> IO (UnitId, UnqualComponentName))
-> TargetsMap -> IO (UnitId, UnqualComponentName)
forall a b. (a -> b) -> a -> b
$ ProjectBuildContext -> TargetsMap
targetsMap ProjectBuildContext
buildCtx
Verbosity -> ProjectBaseContext -> ProjectBuildContext -> IO ()
printPlan Verbosity
verbosity ProjectBaseContext
baseCtx ProjectBuildContext
buildCtx
BuildOutcomes
buildOutcomes <- Verbosity
-> ProjectBaseContext -> ProjectBuildContext -> IO BuildOutcomes
runProjectBuildPhase Verbosity
verbosity ProjectBaseContext
baseCtx ProjectBuildContext
buildCtx
Verbosity
-> ProjectBaseContext
-> ProjectBuildContext
-> BuildOutcomes
-> IO ()
runProjectPostBuildPhase Verbosity
verbosity ProjectBaseContext
baseCtx ProjectBuildContext
buildCtx BuildOutcomes
buildOutcomes
let elaboratedPlan :: ElaboratedInstallPlan
elaboratedPlan = ProjectBuildContext -> ElaboratedInstallPlan
elaboratedPlanToExecute ProjectBuildContext
buildCtx
matchingElaboratedConfiguredPackages :: [ElaboratedConfiguredPackage]
matchingElaboratedConfiguredPackages =
UnitId -> ElaboratedInstallPlan -> [ElaboratedConfiguredPackage]
matchingPackagesByUnitId
UnitId
selectedUnitId
ElaboratedInstallPlan
elaboratedPlan
let exeName :: String
exeName = UnqualComponentName -> String
unUnqualComponentName UnqualComponentName
selectedComponent
ElaboratedConfiguredPackage
pkg <- case [ElaboratedConfiguredPackage]
matchingElaboratedConfiguredPackages of
[] -> Verbosity -> String -> IO ElaboratedConfiguredPackage
forall a. Verbosity -> String -> IO a
die' Verbosity
verbosity (String -> IO ElaboratedConfiguredPackage)
-> String -> IO ElaboratedConfiguredPackage
forall a b. (a -> b) -> a -> b
$ String
"Unknown executable "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
exeName
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" in package "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ UnitId -> String
forall a. Pretty a => a -> String
prettyShow UnitId
selectedUnitId
[ElaboratedConfiguredPackage
elabPkg] -> do
Verbosity -> String -> IO ()
info Verbosity
verbosity (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"Selecting "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ UnitId -> String
forall a. Pretty a => a -> String
prettyShow UnitId
selectedUnitId
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" to supply " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
exeName
ElaboratedConfiguredPackage -> IO ElaboratedConfiguredPackage
forall (m :: * -> *) a. Monad m => a -> m a
return ElaboratedConfiguredPackage
elabPkg
[ElaboratedConfiguredPackage]
elabPkgs -> Verbosity -> String -> IO ElaboratedConfiguredPackage
forall a. Verbosity -> String -> IO a
die' Verbosity
verbosity
(String -> IO ElaboratedConfiguredPackage)
-> String -> IO ElaboratedConfiguredPackage
forall a b. (a -> b) -> a -> b
$ String
"Multiple matching executables found matching "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
exeName
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
":\n"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ [String] -> String
unlines ((ElaboratedConfiguredPackage -> String)
-> [ElaboratedConfiguredPackage] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\ElaboratedConfiguredPackage
p -> String
" - in package " String -> String -> String
forall a. [a] -> [a] -> [a]
++ UnitId -> String
forall a. Pretty a => a -> String
prettyShow (ElaboratedConfiguredPackage -> UnitId
elabUnitId ElaboratedConfiguredPackage
p)) [ElaboratedConfiguredPackage]
elabPkgs)
let exePath :: String
exePath = DistDirLayout
-> ElaboratedSharedConfig
-> ElaboratedConfiguredPackage
-> String
-> String
binDirectoryFor (ProjectBaseContext -> DistDirLayout
distDirLayout ProjectBaseContext
baseCtx)
(ProjectBuildContext -> ElaboratedSharedConfig
elaboratedShared ProjectBuildContext
buildCtx)
ElaboratedConfiguredPackage
pkg
String
exeName
String -> String -> String
</> String
exeName
let dryRun :: Bool
dryRun = BuildTimeSettings -> Bool
buildSettingDryRun (ProjectBaseContext -> BuildTimeSettings
buildSettings ProjectBaseContext
baseCtx)
Bool -> Bool -> Bool
|| BuildTimeSettings -> Bool
buildSettingOnlyDownload (ProjectBaseContext -> BuildTimeSettings
buildSettings ProjectBaseContext
baseCtx)
if Bool
dryRun
then Verbosity -> String -> IO ()
notice Verbosity
verbosity String
"Running of executable suppressed by flag(s)"
else
Verbosity -> ProgramInvocation -> IO ()
runProgramInvocation
Verbosity
verbosity
ProgramInvocation
emptyProgramInvocation {
progInvokePath :: String
progInvokePath = String
exePath,
progInvokeArgs :: [String]
progInvokeArgs = [String]
args,
progInvokeEnv :: [(String, Maybe String)]
progInvokeEnv = DistDirLayout -> ElaboratedInstallPlan -> [(String, Maybe String)]
dataDirsEnvironmentForPlan
(ProjectBaseContext -> DistDirLayout
distDirLayout ProjectBaseContext
baseCtx)
ElaboratedInstallPlan
elaboratedPlan
}
where
([String]
targetStr, [String]
args) = Int -> [String] -> ([String], [String])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
1 [String]
targetAndArgs
validScript :: String -> IO Bool
validScript :: String -> IO Bool
validScript String
script
| String -> Bool
isValid String
script Bool -> Bool -> Bool
&& (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Char -> Bool
isPathSeparator String
script = String -> IO Bool
doesFileExist String
script
| Bool
otherwise = Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
handleShebang :: FilePath -> [String] -> IO ()
handleShebang :: String -> [String] -> IO ()
handleShebang String
script [String]
args =
NixStyleFlags () -> [String] -> GlobalFlags -> IO ()
runAction (CommandUI (NixStyleFlags ()) -> NixStyleFlags ()
forall flags. CommandUI flags -> flags
commandDefaultFlags CommandUI (NixStyleFlags ())
runCommand) (String
scriptString -> [String] -> [String]
forall a. a -> [a] -> [a]
:[String]
args) GlobalFlags
defaultGlobalFlags
singleExeOrElse :: IO (UnitId, UnqualComponentName) -> TargetsMap -> IO (UnitId, UnqualComponentName)
singleExeOrElse :: IO (UnitId, UnqualComponentName)
-> TargetsMap -> IO (UnitId, UnqualComponentName)
singleExeOrElse IO (UnitId, UnqualComponentName)
action TargetsMap
targetsMap =
case Set (UnitId, ComponentName) -> [(UnitId, ComponentName)]
forall a. Set a -> [a]
Set.toList (Set (UnitId, ComponentName) -> [(UnitId, ComponentName)])
-> (TargetsMap -> Set (UnitId, ComponentName))
-> TargetsMap
-> [(UnitId, ComponentName)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TargetsMap -> Set (UnitId, ComponentName)
distinctTargetComponents (TargetsMap -> [(UnitId, ComponentName)])
-> TargetsMap -> [(UnitId, ComponentName)]
forall a b. (a -> b) -> a -> b
$ TargetsMap
targetsMap
of [(UnitId
unitId, CExeName UnqualComponentName
component)] -> (UnitId, UnqualComponentName) -> IO (UnitId, UnqualComponentName)
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitId
unitId, UnqualComponentName
component)
[(UnitId
unitId, CTestName UnqualComponentName
component)] -> (UnitId, UnqualComponentName) -> IO (UnitId, UnqualComponentName)
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitId
unitId, UnqualComponentName
component)
[(UnitId
unitId, CBenchName UnqualComponentName
component)] -> (UnitId, UnqualComponentName) -> IO (UnitId, UnqualComponentName)
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitId
unitId, UnqualComponentName
component)
[(UnitId, ComponentName)]
_ -> IO (UnitId, UnqualComponentName)
action
matchingPackagesByUnitId :: UnitId
-> ElaboratedInstallPlan
-> [ElaboratedConfiguredPackage]
matchingPackagesByUnitId :: UnitId -> ElaboratedInstallPlan -> [ElaboratedConfiguredPackage]
matchingPackagesByUnitId UnitId
uid =
[Maybe ElaboratedConfiguredPackage]
-> [ElaboratedConfiguredPackage]
forall a. [Maybe a] -> [a]
catMaybes
([Maybe ElaboratedConfiguredPackage]
-> [ElaboratedConfiguredPackage])
-> (ElaboratedInstallPlan -> [Maybe ElaboratedConfiguredPackage])
-> ElaboratedInstallPlan
-> [ElaboratedConfiguredPackage]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage
-> Maybe ElaboratedConfiguredPackage)
-> [GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage]
-> [Maybe ElaboratedConfiguredPackage]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((InstalledPackageInfo -> Maybe ElaboratedConfiguredPackage)
-> (ElaboratedConfiguredPackage
-> Maybe ElaboratedConfiguredPackage)
-> GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage
-> Maybe ElaboratedConfiguredPackage
forall ipkg a srcpkg.
(ipkg -> a) -> (srcpkg -> a) -> GenericPlanPackage ipkg srcpkg -> a
foldPlanPackage
(Maybe ElaboratedConfiguredPackage
-> InstalledPackageInfo -> Maybe ElaboratedConfiguredPackage
forall a b. a -> b -> a
const Maybe ElaboratedConfiguredPackage
forall a. Maybe a
Nothing)
(\ElaboratedConfiguredPackage
x -> if ElaboratedConfiguredPackage -> UnitId
elabUnitId ElaboratedConfiguredPackage
x UnitId -> UnitId -> Bool
forall a. Eq a => a -> a -> Bool
== UnitId
uid
then ElaboratedConfiguredPackage -> Maybe ElaboratedConfiguredPackage
forall a. a -> Maybe a
Just ElaboratedConfiguredPackage
x
else Maybe ElaboratedConfiguredPackage
forall a. Maybe a
Nothing))
([GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage]
-> [Maybe ElaboratedConfiguredPackage])
-> (ElaboratedInstallPlan
-> [GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage])
-> ElaboratedInstallPlan
-> [Maybe ElaboratedConfiguredPackage]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedInstallPlan
-> [GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage]
forall ipkg srcpkg.
GenericInstallPlan ipkg srcpkg -> [GenericPlanPackage ipkg srcpkg]
toList
selectPackageTargets :: TargetSelector
-> [AvailableTarget k] -> Either RunTargetProblem [k]
selectPackageTargets :: TargetSelector
-> [AvailableTarget k] -> Either RunTargetProblem [k]
selectPackageTargets TargetSelector
targetSelector [AvailableTarget k]
targets
| [k
target] <- [k]
targetsExesBuildable
= [k] -> Either RunTargetProblem [k]
forall a b. b -> Either a b
Right [k
target]
| [k
target] <- [k]
targetsExeLikesBuildable
= [k] -> Either RunTargetProblem [k]
forall a b. b -> Either a b
Right [k
target]
| Bool -> Bool
not ([k] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [k]
targetsExeLikesBuildable)
= RunTargetProblem -> Either RunTargetProblem [k]
forall a b. a -> Either a b
Left (TargetSelector -> [AvailableTarget ()] -> RunTargetProblem
matchesMultipleProblem TargetSelector
targetSelector [AvailableTarget ()]
targetsExeLikesBuildable')
| Bool -> Bool
not ([AvailableTarget ()] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [AvailableTarget ()]
targetsExeLikes')
= RunTargetProblem -> Either RunTargetProblem [k]
forall a b. a -> Either a b
Left (TargetSelector -> [AvailableTarget ()] -> RunTargetProblem
forall a. TargetSelector -> [AvailableTarget ()] -> TargetProblem a
TargetProblemNoneEnabled TargetSelector
targetSelector [AvailableTarget ()]
targetsExeLikes')
| Bool -> Bool
not ([AvailableTarget k] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [AvailableTarget k]
targets)
= RunTargetProblem -> Either RunTargetProblem [k]
forall a b. a -> Either a b
Left (TargetSelector -> RunTargetProblem
noExesProblem TargetSelector
targetSelector)
| Bool
otherwise
= RunTargetProblem -> Either RunTargetProblem [k]
forall a b. a -> Either a b
Left (TargetSelector -> RunTargetProblem
forall a. TargetSelector -> TargetProblem a
TargetProblemNoTargets TargetSelector
targetSelector)
where
targetsExes :: [AvailableTarget k]
targetsExes = ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
forall k.
ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
filterTargetsKind ComponentKind
ExeKind [AvailableTarget k]
targets
targetsExesBuildable :: [k]
targetsExesBuildable = [AvailableTarget k] -> [k]
forall k. [AvailableTarget k] -> [k]
selectBuildableTargets [AvailableTarget k]
targetsExes
targetsExeLikes :: [AvailableTarget k]
targetsExeLikes = [AvailableTarget k]
targetsExes
[AvailableTarget k] -> [AvailableTarget k] -> [AvailableTarget k]
forall a. [a] -> [a] -> [a]
++ ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
forall k.
ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
filterTargetsKind ComponentKind
TestKind [AvailableTarget k]
targets
[AvailableTarget k] -> [AvailableTarget k] -> [AvailableTarget k]
forall a. [a] -> [a] -> [a]
++ ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
forall k.
ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
filterTargetsKind ComponentKind
BenchKind [AvailableTarget k]
targets
([k]
targetsExeLikesBuildable,
[AvailableTarget ()]
targetsExeLikesBuildable') = [AvailableTarget k] -> ([k], [AvailableTarget ()])
forall k. [AvailableTarget k] -> ([k], [AvailableTarget ()])
selectBuildableTargets' [AvailableTarget k]
targetsExeLikes
targetsExeLikes' :: [AvailableTarget ()]
targetsExeLikes' = [AvailableTarget k] -> [AvailableTarget ()]
forall k. [AvailableTarget k] -> [AvailableTarget ()]
forgetTargetsDetail [AvailableTarget k]
targetsExeLikes
selectComponentTarget :: SubComponentTarget
-> AvailableTarget k -> Either RunTargetProblem k
selectComponentTarget :: SubComponentTarget
-> AvailableTarget k -> Either RunTargetProblem k
selectComponentTarget subtarget :: SubComponentTarget
subtarget@SubComponentTarget
WholeComponent AvailableTarget k
t
= case AvailableTarget k -> ComponentName
forall k. AvailableTarget k -> ComponentName
availableTargetComponentName AvailableTarget k
t
of CExeName UnqualComponentName
_ -> Either RunTargetProblem k
forall a. Either (TargetProblem a) k
component
CTestName UnqualComponentName
_ -> Either RunTargetProblem k
forall a. Either (TargetProblem a) k
component
CBenchName UnqualComponentName
_ -> Either RunTargetProblem k
forall a. Either (TargetProblem a) k
component
ComponentName
_ -> RunTargetProblem -> Either RunTargetProblem k
forall a b. a -> Either a b
Left (PackageId -> ComponentName -> RunTargetProblem
componentNotExeProblem PackageId
pkgid ComponentName
cname)
where pkgid :: PackageId
pkgid = AvailableTarget k -> PackageId
forall k. AvailableTarget k -> PackageId
availableTargetPackageId AvailableTarget k
t
cname :: ComponentName
cname = AvailableTarget k -> ComponentName
forall k. AvailableTarget k -> ComponentName
availableTargetComponentName AvailableTarget k
t
component :: Either (TargetProblem a) k
component = SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem a) k
forall k a.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem a) k
selectComponentTargetBasic SubComponentTarget
subtarget AvailableTarget k
t
selectComponentTarget SubComponentTarget
subtarget AvailableTarget k
t
= RunTargetProblem -> Either RunTargetProblem k
forall a b. a -> Either a b
Left (PackageId
-> ComponentName -> SubComponentTarget -> RunTargetProblem
isSubComponentProblem (AvailableTarget k -> PackageId
forall k. AvailableTarget k -> PackageId
availableTargetPackageId AvailableTarget k
t)
(AvailableTarget k -> ComponentName
forall k. AvailableTarget k -> ComponentName
availableTargetComponentName AvailableTarget k
t)
SubComponentTarget
subtarget)
data RunProblem =
TargetProblemNoExes TargetSelector
| TargetProblemMatchesMultiple TargetSelector [AvailableTarget ()]
| TargetProblemMultipleTargets TargetsMap
| TargetProblemComponentNotExe PackageId ComponentName
| TargetProblemIsSubComponent PackageId ComponentName SubComponentTarget
deriving (RunProblem -> RunProblem -> Bool
(RunProblem -> RunProblem -> Bool)
-> (RunProblem -> RunProblem -> Bool) -> Eq RunProblem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RunProblem -> RunProblem -> Bool
$c/= :: RunProblem -> RunProblem -> Bool
== :: RunProblem -> RunProblem -> Bool
$c== :: RunProblem -> RunProblem -> Bool
Eq, Int -> RunProblem -> String -> String
[RunProblem] -> String -> String
RunProblem -> String
(Int -> RunProblem -> String -> String)
-> (RunProblem -> String)
-> ([RunProblem] -> String -> String)
-> Show RunProblem
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [RunProblem] -> String -> String
$cshowList :: [RunProblem] -> String -> String
show :: RunProblem -> String
$cshow :: RunProblem -> String
showsPrec :: Int -> RunProblem -> String -> String
$cshowsPrec :: Int -> RunProblem -> String -> String
Show)
type RunTargetProblem = TargetProblem RunProblem
noExesProblem :: TargetSelector -> RunTargetProblem
noExesProblem :: TargetSelector -> RunTargetProblem
noExesProblem = RunProblem -> RunTargetProblem
forall a. a -> TargetProblem a
CustomTargetProblem (RunProblem -> RunTargetProblem)
-> (TargetSelector -> RunProblem)
-> TargetSelector
-> RunTargetProblem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TargetSelector -> RunProblem
TargetProblemNoExes
matchesMultipleProblem :: TargetSelector -> [AvailableTarget ()] -> RunTargetProblem
matchesMultipleProblem :: TargetSelector -> [AvailableTarget ()] -> RunTargetProblem
matchesMultipleProblem TargetSelector
selector [AvailableTarget ()]
targets = RunProblem -> RunTargetProblem
forall a. a -> TargetProblem a
CustomTargetProblem (RunProblem -> RunTargetProblem) -> RunProblem -> RunTargetProblem
forall a b. (a -> b) -> a -> b
$
TargetSelector -> [AvailableTarget ()] -> RunProblem
TargetProblemMatchesMultiple TargetSelector
selector [AvailableTarget ()]
targets
multipleTargetsProblem :: TargetsMap -> TargetProblem RunProblem
multipleTargetsProblem :: TargetsMap -> RunTargetProblem
multipleTargetsProblem = RunProblem -> RunTargetProblem
forall a. a -> TargetProblem a
CustomTargetProblem (RunProblem -> RunTargetProblem)
-> (TargetsMap -> RunProblem) -> TargetsMap -> RunTargetProblem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TargetsMap -> RunProblem
TargetProblemMultipleTargets
componentNotExeProblem :: PackageId -> ComponentName -> TargetProblem RunProblem
componentNotExeProblem :: PackageId -> ComponentName -> RunTargetProblem
componentNotExeProblem PackageId
pkgid ComponentName
name = RunProblem -> RunTargetProblem
forall a. a -> TargetProblem a
CustomTargetProblem (RunProblem -> RunTargetProblem) -> RunProblem -> RunTargetProblem
forall a b. (a -> b) -> a -> b
$
PackageId -> ComponentName -> RunProblem
TargetProblemComponentNotExe PackageId
pkgid ComponentName
name
isSubComponentProblem
:: PackageId
-> ComponentName
-> SubComponentTarget
-> TargetProblem RunProblem
isSubComponentProblem :: PackageId
-> ComponentName -> SubComponentTarget -> RunTargetProblem
isSubComponentProblem PackageId
pkgid ComponentName
name SubComponentTarget
subcomponent = RunProblem -> RunTargetProblem
forall a. a -> TargetProblem a
CustomTargetProblem (RunProblem -> RunTargetProblem) -> RunProblem -> RunTargetProblem
forall a b. (a -> b) -> a -> b
$
PackageId -> ComponentName -> SubComponentTarget -> RunProblem
TargetProblemIsSubComponent PackageId
pkgid ComponentName
name SubComponentTarget
subcomponent
reportTargetProblems :: Verbosity -> [RunTargetProblem] -> IO a
reportTargetProblems :: Verbosity -> [RunTargetProblem] -> IO a
reportTargetProblems Verbosity
verbosity =
Verbosity -> String -> IO a
forall a. Verbosity -> String -> IO a
die' Verbosity
verbosity (String -> IO a)
-> ([RunTargetProblem] -> String) -> [RunTargetProblem] -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> String
unlines ([String] -> String)
-> ([RunTargetProblem] -> [String]) -> [RunTargetProblem] -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RunTargetProblem -> String) -> [RunTargetProblem] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map RunTargetProblem -> String
renderRunTargetProblem
renderRunTargetProblem :: RunTargetProblem -> String
renderRunTargetProblem :: RunTargetProblem -> String
renderRunTargetProblem (TargetProblemNoTargets TargetSelector
targetSelector) =
case TargetSelector -> Maybe ComponentKind
targetSelectorFilter TargetSelector
targetSelector of
Just ComponentKind
kind | ComponentKind
kind ComponentKind -> ComponentKind -> Bool
forall a. Eq a => a -> a -> Bool
/= ComponentKind
ExeKind
-> String
"The run command is for running executables, but the target '"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
showTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' refers to "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
renderTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"."
Maybe ComponentKind
_ -> String -> TargetSelector -> String
renderTargetProblemNoTargets String
"run" TargetSelector
targetSelector
renderRunTargetProblem RunTargetProblem
problem =
String -> (RunProblem -> String) -> RunTargetProblem -> String
forall a. String -> (a -> String) -> TargetProblem a -> String
renderTargetProblem String
"run" RunProblem -> String
renderRunProblem RunTargetProblem
problem
renderRunProblem :: RunProblem -> String
renderRunProblem :: RunProblem -> String
renderRunProblem (TargetProblemMatchesMultiple TargetSelector
targetSelector [AvailableTarget ()]
targets) =
String
"The run command is for running a single executable at once. The target '"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
showTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' refers to "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
renderTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" which includes "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ [String] -> String
renderListCommaAnd ( (String
"the "String -> String -> String
forall a. [a] -> [a] -> [a]
++) (String -> String)
-> (ComponentName -> String) -> ComponentName -> String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
ComponentName -> String
showComponentName (ComponentName -> String)
-> (AvailableTarget () -> ComponentName)
-> AvailableTarget ()
-> String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
AvailableTarget () -> ComponentName
forall k. AvailableTarget k -> ComponentName
availableTargetComponentName (AvailableTarget () -> String) -> [AvailableTarget ()] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
(ComponentKind -> [AvailableTarget ()])
-> [ComponentKind] -> [AvailableTarget ()]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap
(\ComponentKind
kind -> ComponentKind -> [AvailableTarget ()] -> [AvailableTarget ()]
forall k.
ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
filterTargetsKind ComponentKind
kind [AvailableTarget ()]
targets)
[ComponentKind
ExeKind, ComponentKind
TestKind, ComponentKind
BenchKind] )
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"."
renderRunProblem (TargetProblemMultipleTargets TargetsMap
selectorMap) =
String
"The run command is for running a single executable at once. The targets "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ [String] -> String
renderListCommaAnd [ String
"'" String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
showTargetSelector TargetSelector
ts String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"'"
| TargetSelector
ts <- TargetsMap -> [TargetSelector]
uniqueTargetSelectors TargetsMap
selectorMap ]
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" refer to different executables."
renderRunProblem (TargetProblemComponentNotExe PackageId
pkgid ComponentName
cname) =
String
"The run command is for running executables, but the target '"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
showTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' refers to "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
renderTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" from the package "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ PackageId -> String
forall a. Pretty a => a -> String
prettyShow PackageId
pkgid String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"."
where
targetSelector :: TargetSelector
targetSelector = PackageId -> ComponentName -> SubComponentTarget -> TargetSelector
TargetComponent PackageId
pkgid ComponentName
cname SubComponentTarget
WholeComponent
renderRunProblem (TargetProblemIsSubComponent PackageId
pkgid ComponentName
cname SubComponentTarget
subtarget) =
String
"The run command can only run an executable as a whole, "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"not files or modules within them, but the target '"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
showTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' refers to "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
renderTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"."
where
targetSelector :: TargetSelector
targetSelector = PackageId -> ComponentName -> SubComponentTarget -> TargetSelector
TargetComponent PackageId
pkgid ComponentName
cname SubComponentTarget
subtarget
renderRunProblem (TargetProblemNoExes TargetSelector
targetSelector) =
String
"Cannot run the target '" String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
showTargetSelector TargetSelector
targetSelector
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' which refers to " String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
renderTargetSelector TargetSelector
targetSelector
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" because "
String -> String -> String
forall a. [a] -> [a] -> [a]
++ Plural -> String -> String -> String
forall a. Plural -> a -> a -> a
plural (TargetSelector -> Plural
targetSelectorPluralPkgs TargetSelector
targetSelector) String
"it does" String
"they do"
String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" not contain any executables."