module Distribution.Client.Init.Simple
( -- * Project creation
  createProject
  -- * Gen targets
, genSimplePkgDesc
, genSimpleLibTarget
, genSimpleExeTarget
, genSimpleTestTarget
) where


import Distribution.Client.Init.Types
import Distribution.Verbosity
import Distribution.Simple.PackageIndex
import Distribution.Client.Types.SourcePackageDb (SourcePackageDb(..))
import qualified Data.List.NonEmpty as NEL
import Distribution.Client.Init.Utils (currentDirPkgName, mkPackageNameDep, fixupDocFiles)
import Distribution.Client.Init.Defaults
import Distribution.Simple.Flag (fromFlagOrDefault, flagElim, Flag(..))
import Distribution.Client.Init.FlagExtractors
import qualified Data.Set as Set
import Distribution.Types.Dependency
import Distribution.Types.PackageName (unPackageName)


createProject
    :: Interactive m
    => Verbosity
    -> InstalledPackageIndex
    -> SourcePackageDb
    -> InitFlags
    -> m ProjectSettings
createProject :: Verbosity
-> InstalledPackageIndex
-> SourcePackageDb
-> InitFlags
-> m ProjectSettings
createProject Verbosity
v InstalledPackageIndex
pkgIx SourcePackageDb
_srcDb InitFlags
initFlags = do
    PackageType
pkgType <- InitFlags -> m PackageType
forall (m :: * -> *). Interactive m => InitFlags -> m PackageType
packageTypePrompt InitFlags
initFlags
    Bool
isMinimal <- InitFlags -> m Bool
forall (m :: * -> *). Interactive m => InitFlags -> m Bool
getMinimal InitFlags
initFlags
    Bool
doOverwrite <- InitFlags -> m Bool
forall (m :: * -> *). Interactive m => InitFlags -> m Bool
getOverwrite InitFlags
initFlags
    FilePath
pkgDir <- InitFlags -> m FilePath
forall (m :: * -> *). Interactive m => InitFlags -> m FilePath
getPackageDir InitFlags
initFlags
    PkgDescription
pkgDesc <- Verbosity -> PkgDescription -> m PkgDescription
forall (m :: * -> *).
Interactive m =>
Verbosity -> PkgDescription -> m PkgDescription
fixupDocFiles Verbosity
v (PkgDescription -> m PkgDescription)
-> m PkgDescription -> m PkgDescription
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< InitFlags -> m PkgDescription
forall (m :: * -> *).
Interactive m =>
InitFlags -> m PkgDescription
genSimplePkgDesc InitFlags
initFlags

    let pkgName :: PackageName
pkgName = PkgDescription -> PackageName
_pkgName PkgDescription
pkgDesc
        cabalSpec :: CabalSpecVersion
cabalSpec = PkgDescription -> CabalSpecVersion
_pkgCabalVersion PkgDescription
pkgDesc
        mkOpts :: Bool -> CabalSpecVersion -> WriteOpts
mkOpts Bool
cs = Bool
-> Bool
-> Bool
-> Verbosity
-> FilePath
-> PackageType
-> PackageName
-> CabalSpecVersion
-> WriteOpts
WriteOpts
          Bool
doOverwrite Bool
isMinimal Bool
cs
          Verbosity
v FilePath
pkgDir PackageType
pkgType PackageName
pkgName

    InitFlags
basedFlags <- InstalledPackageIndex -> InitFlags -> m InitFlags
forall (m :: * -> *).
Interactive m =>
InstalledPackageIndex -> InitFlags -> m InitFlags
addBaseDepToFlags InstalledPackageIndex
pkgIx InitFlags
initFlags

    case PackageType
pkgType of
      PackageType
Library -> do
        LibTarget
libTarget <- InitFlags -> m LibTarget
forall (m :: * -> *). Interactive m => InitFlags -> m LibTarget
genSimpleLibTarget InitFlags
basedFlags
        Maybe TestTarget
testTarget <- PackageName -> Maybe TestTarget -> Maybe TestTarget
addLibDepToTest PackageName
pkgName (Maybe TestTarget -> Maybe TestTarget)
-> m (Maybe TestTarget) -> m (Maybe TestTarget)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> InitFlags -> m (Maybe TestTarget)
forall (m :: * -> *).
Interactive m =>
InitFlags -> m (Maybe TestTarget)
genSimpleTestTarget InitFlags
basedFlags
        ProjectSettings -> m ProjectSettings
forall (m :: * -> *) a. Monad m => a -> m a
return (ProjectSettings -> m ProjectSettings)
-> ProjectSettings -> m ProjectSettings
forall a b. (a -> b) -> a -> b
$ WriteOpts
-> PkgDescription
-> Maybe LibTarget
-> Maybe ExeTarget
-> Maybe TestTarget
-> ProjectSettings
ProjectSettings
          (Bool -> CabalSpecVersion -> WriteOpts
mkOpts Bool
False CabalSpecVersion
cabalSpec) PkgDescription
pkgDesc
          (LibTarget -> Maybe LibTarget
forall a. a -> Maybe a
Just LibTarget
libTarget) Maybe ExeTarget
forall a. Maybe a
Nothing Maybe TestTarget
testTarget

      PackageType
Executable -> do
        ExeTarget
exeTarget <- InitFlags -> m ExeTarget
forall (m :: * -> *). Interactive m => InitFlags -> m ExeTarget
genSimpleExeTarget InitFlags
basedFlags
        ProjectSettings -> m ProjectSettings
forall (m :: * -> *) a. Monad m => a -> m a
return (ProjectSettings -> m ProjectSettings)
-> ProjectSettings -> m ProjectSettings
forall a b. (a -> b) -> a -> b
$ WriteOpts
-> PkgDescription
-> Maybe LibTarget
-> Maybe ExeTarget
-> Maybe TestTarget
-> ProjectSettings
ProjectSettings
          (Bool -> CabalSpecVersion -> WriteOpts
mkOpts Bool
False CabalSpecVersion
cabalSpec) PkgDescription
pkgDesc
          Maybe LibTarget
forall a. Maybe a
Nothing (ExeTarget -> Maybe ExeTarget
forall a. a -> Maybe a
Just ExeTarget
exeTarget) Maybe TestTarget
forall a. Maybe a
Nothing

      PackageType
LibraryAndExecutable -> do
        LibTarget
libTarget <- InitFlags -> m LibTarget
forall (m :: * -> *). Interactive m => InitFlags -> m LibTarget
genSimpleLibTarget InitFlags
basedFlags
        Maybe TestTarget
testTarget <- PackageName -> Maybe TestTarget -> Maybe TestTarget
addLibDepToTest PackageName
pkgName (Maybe TestTarget -> Maybe TestTarget)
-> m (Maybe TestTarget) -> m (Maybe TestTarget)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> InitFlags -> m (Maybe TestTarget)
forall (m :: * -> *).
Interactive m =>
InitFlags -> m (Maybe TestTarget)
genSimpleTestTarget InitFlags
basedFlags
        ExeTarget
exeTarget <- PackageName -> ExeTarget -> ExeTarget
addLibDepToExe PackageName
pkgName (ExeTarget -> ExeTarget) -> m ExeTarget -> m ExeTarget
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> InitFlags -> m ExeTarget
forall (m :: * -> *). Interactive m => InitFlags -> m ExeTarget
genSimpleExeTarget InitFlags
basedFlags
        ProjectSettings -> m ProjectSettings
forall (m :: * -> *) a. Monad m => a -> m a
return (ProjectSettings -> m ProjectSettings)
-> ProjectSettings -> m ProjectSettings
forall a b. (a -> b) -> a -> b
$ WriteOpts
-> PkgDescription
-> Maybe LibTarget
-> Maybe ExeTarget
-> Maybe TestTarget
-> ProjectSettings
ProjectSettings
          (Bool -> CabalSpecVersion -> WriteOpts
mkOpts Bool
False CabalSpecVersion
cabalSpec) PkgDescription
pkgDesc
          (LibTarget -> Maybe LibTarget
forall a. a -> Maybe a
Just LibTarget
libTarget) (ExeTarget -> Maybe ExeTarget
forall a. a -> Maybe a
Just ExeTarget
exeTarget) Maybe TestTarget
testTarget

      PackageType
TestSuite -> do
        Maybe TestTarget
testTarget <- InitFlags -> m (Maybe TestTarget)
forall (m :: * -> *).
Interactive m =>
InitFlags -> m (Maybe TestTarget)
genSimpleTestTarget InitFlags
basedFlags
        ProjectSettings -> m ProjectSettings
forall (m :: * -> *) a. Monad m => a -> m a
return (ProjectSettings -> m ProjectSettings)
-> ProjectSettings -> m ProjectSettings
forall a b. (a -> b) -> a -> b
$ WriteOpts
-> PkgDescription
-> Maybe LibTarget
-> Maybe ExeTarget
-> Maybe TestTarget
-> ProjectSettings
ProjectSettings
          (Bool -> CabalSpecVersion -> WriteOpts
mkOpts Bool
False CabalSpecVersion
cabalSpec) PkgDescription
pkgDesc
          Maybe LibTarget
forall a. Maybe a
Nothing Maybe ExeTarget
forall a. Maybe a
Nothing Maybe TestTarget
testTarget
  where
    -- Add package name as dependency of test suite
    --
    addLibDepToTest :: PackageName -> Maybe TestTarget -> Maybe TestTarget
addLibDepToTest PackageName
_ Maybe TestTarget
Nothing = Maybe TestTarget
forall a. Maybe a
Nothing
    addLibDepToTest PackageName
n (Just TestTarget
t) = TestTarget -> Maybe TestTarget
forall a. a -> Maybe a
Just (TestTarget -> Maybe TestTarget) -> TestTarget -> Maybe TestTarget
forall a b. (a -> b) -> a -> b
$ TestTarget
t
      { _testDependencies :: [Dependency]
_testDependencies = TestTarget -> [Dependency]
_testDependencies TestTarget
t [Dependency] -> [Dependency] -> [Dependency]
forall a. [a] -> [a] -> [a]
++ [PackageName -> Dependency
mkPackageNameDep PackageName
n]
      }

    -- Add package name as dependency of executable
    --
    addLibDepToExe :: PackageName -> ExeTarget -> ExeTarget
addLibDepToExe PackageName
n ExeTarget
exe = ExeTarget
exe
      { _exeDependencies :: [Dependency]
_exeDependencies = ExeTarget -> [Dependency]
_exeDependencies ExeTarget
exe [Dependency] -> [Dependency] -> [Dependency]
forall a. [a] -> [a] -> [a]
++ [PackageName -> Dependency
mkPackageNameDep PackageName
n]
      }

genSimplePkgDesc :: Interactive m => InitFlags -> m PkgDescription
genSimplePkgDesc :: InitFlags -> m PkgDescription
genSimplePkgDesc InitFlags
flags = PackageName -> PkgDescription
mkPkgDesc (PackageName -> PkgDescription)
-> m PackageName -> m PkgDescription
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m PackageName
forall (m :: * -> *). Interactive m => m PackageName
currentDirPkgName
  where
    defaultExtraDoc :: Maybe (Set FilePath)
defaultExtraDoc = Set FilePath -> Maybe (Set FilePath)
forall a. a -> Maybe a
Just (Set FilePath -> Maybe (Set FilePath))
-> Set FilePath -> Maybe (Set FilePath)
forall a b. (a -> b) -> a -> b
$ FilePath -> Set FilePath
forall a. a -> Set a
Set.singleton FilePath
defaultChangelog

    extractExtraDoc :: [FilePath] -> Maybe (Set FilePath)
extractExtraDoc [] = Maybe (Set FilePath)
defaultExtraDoc
    extractExtraDoc [FilePath]
fs = Set FilePath -> Maybe (Set FilePath)
forall a. a -> Maybe a
Just (Set FilePath -> Maybe (Set FilePath))
-> Set FilePath -> Maybe (Set FilePath)
forall a b. (a -> b) -> a -> b
$ [FilePath] -> Set FilePath
forall a. Ord a => [a] -> Set a
Set.fromList [FilePath]
fs

    mkPkgDesc :: PackageName -> PkgDescription
mkPkgDesc PackageName
pkgName = CabalSpecVersion
-> PackageName
-> Version
-> SpecLicense
-> FilePath
-> FilePath
-> FilePath
-> FilePath
-> FilePath
-> Set FilePath
-> Maybe (Set FilePath)
-> PkgDescription
PkgDescription
      (CabalSpecVersion -> Flag CabalSpecVersion -> CabalSpecVersion
forall a. a -> Flag a -> a
fromFlagOrDefault CabalSpecVersion
defaultCabalVersion (InitFlags -> Flag CabalSpecVersion
cabalVersion InitFlags
flags))
      PackageName
pkgName
      (Version -> Flag Version -> Version
forall a. a -> Flag a -> a
fromFlagOrDefault Version
defaultVersion (InitFlags -> Flag Version
version InitFlags
flags))
      (SpecLicense -> Flag SpecLicense -> SpecLicense
forall a. a -> Flag a -> a
fromFlagOrDefault (CabalSpecVersion -> SpecLicense
defaultLicense (CabalSpecVersion -> SpecLicense)
-> CabalSpecVersion -> SpecLicense
forall a b. (a -> b) -> a -> b
$ InitFlags -> CabalSpecVersion
getCabalVersionNoPrompt InitFlags
flags) (InitFlags -> Flag SpecLicense
license InitFlags
flags))
      (FilePath -> Flag FilePath -> FilePath
forall a. a -> Flag a -> a
fromFlagOrDefault FilePath
"" (InitFlags -> Flag FilePath
author InitFlags
flags))
      (FilePath -> Flag FilePath -> FilePath
forall a. a -> Flag a -> a
fromFlagOrDefault FilePath
"" (InitFlags -> Flag FilePath
email InitFlags
flags))
      (FilePath -> Flag FilePath -> FilePath
forall a. a -> Flag a -> a
fromFlagOrDefault FilePath
"" (InitFlags -> Flag FilePath
homepage InitFlags
flags))
      (FilePath -> Flag FilePath -> FilePath
forall a. a -> Flag a -> a
fromFlagOrDefault FilePath
"" (InitFlags -> Flag FilePath
synopsis InitFlags
flags))
      (FilePath -> Flag FilePath -> FilePath
forall a. a -> Flag a -> a
fromFlagOrDefault FilePath
"" (InitFlags -> Flag FilePath
category InitFlags
flags))
      (Set FilePath
-> ([FilePath] -> Set FilePath) -> Flag [FilePath] -> Set FilePath
forall b a. b -> (a -> b) -> Flag a -> b
flagElim Set FilePath
forall a. Monoid a => a
mempty [FilePath] -> Set FilePath
forall a. Ord a => [a] -> Set a
Set.fromList (InitFlags -> Flag [FilePath]
extraSrc InitFlags
flags))
      (Maybe (Set FilePath)
-> ([FilePath] -> Maybe (Set FilePath))
-> Flag [FilePath]
-> Maybe (Set FilePath)
forall b a. b -> (a -> b) -> Flag a -> b
flagElim Maybe (Set FilePath)
defaultExtraDoc [FilePath] -> Maybe (Set FilePath)
extractExtraDoc (InitFlags -> Flag [FilePath]
extraDoc InitFlags
flags))

genSimpleLibTarget :: Interactive m => InitFlags -> m LibTarget
genSimpleLibTarget :: InitFlags -> m LibTarget
genSimpleLibTarget InitFlags
flags = do
    [Dependency]
buildToolDeps <- InitFlags -> m [Dependency]
forall (m :: * -> *). Interactive m => InitFlags -> m [Dependency]
getBuildTools InitFlags
flags
    LibTarget -> m LibTarget
forall (m :: * -> *) a. Monad m => a -> m a
return (LibTarget -> m LibTarget) -> LibTarget -> m LibTarget
forall a b. (a -> b) -> a -> b
$ LibTarget :: [FilePath]
-> Language
-> NonEmpty ModuleName
-> [ModuleName]
-> [Extension]
-> [Dependency]
-> [Dependency]
-> LibTarget
LibTarget
      { _libSourceDirs :: [FilePath]
_libSourceDirs = [FilePath] -> Flag [FilePath] -> [FilePath]
forall a. a -> Flag a -> a
fromFlagOrDefault [FilePath
defaultSourceDir] (Flag [FilePath] -> [FilePath]) -> Flag [FilePath] -> [FilePath]
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [FilePath]
sourceDirs InitFlags
flags
      , _libLanguage :: Language
_libLanguage = Language -> Flag Language -> Language
forall a. a -> Flag a -> a
fromFlagOrDefault Language
defaultLanguage (Flag Language -> Language) -> Flag Language -> Language
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag Language
language InitFlags
flags
      , _libExposedModules :: NonEmpty ModuleName
_libExposedModules =
        NonEmpty ModuleName
-> ([ModuleName] -> NonEmpty ModuleName)
-> Flag [ModuleName]
-> NonEmpty ModuleName
forall b a. b -> (a -> b) -> Flag a -> b
flagElim (ModuleName
myLibModule ModuleName -> [ModuleName] -> NonEmpty ModuleName
forall a. a -> [a] -> NonEmpty a
NEL.:| []) [ModuleName] -> NonEmpty ModuleName
extractMods (Flag [ModuleName] -> NonEmpty ModuleName)
-> Flag [ModuleName] -> NonEmpty ModuleName
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [ModuleName]
exposedModules InitFlags
flags
      , _libOtherModules :: [ModuleName]
_libOtherModules = [ModuleName] -> Flag [ModuleName] -> [ModuleName]
forall a. a -> Flag a -> a
fromFlagOrDefault [] (Flag [ModuleName] -> [ModuleName])
-> Flag [ModuleName] -> [ModuleName]
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [ModuleName]
otherModules InitFlags
flags
      , _libOtherExts :: [Extension]
_libOtherExts = [Extension] -> Flag [Extension] -> [Extension]
forall a. a -> Flag a -> a
fromFlagOrDefault [] (Flag [Extension] -> [Extension])
-> Flag [Extension] -> [Extension]
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [Extension]
otherExts InitFlags
flags
      , _libDependencies :: [Dependency]
_libDependencies = [Dependency] -> Flag [Dependency] -> [Dependency]
forall a. a -> Flag a -> a
fromFlagOrDefault [] (Flag [Dependency] -> [Dependency])
-> Flag [Dependency] -> [Dependency]
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [Dependency]
dependencies InitFlags
flags
      , _libBuildTools :: [Dependency]
_libBuildTools = [Dependency]
buildToolDeps
      }

  where
    extractMods :: [ModuleName] -> NonEmpty ModuleName
extractMods [] = ModuleName
myLibModule ModuleName -> [ModuleName] -> NonEmpty ModuleName
forall a. a -> [a] -> NonEmpty a
NEL.:| []
    extractMods [ModuleName]
as = [ModuleName] -> NonEmpty ModuleName
forall a. [a] -> NonEmpty a
NEL.fromList [ModuleName]
as

genSimpleExeTarget :: Interactive m => InitFlags -> m ExeTarget
genSimpleExeTarget :: InitFlags -> m ExeTarget
genSimpleExeTarget InitFlags
flags = do
    [Dependency]
buildToolDeps <- InitFlags -> m [Dependency]
forall (m :: * -> *). Interactive m => InitFlags -> m [Dependency]
getBuildTools InitFlags
flags
    ExeTarget -> m ExeTarget
forall (m :: * -> *) a. Monad m => a -> m a
return (ExeTarget -> m ExeTarget) -> ExeTarget -> m ExeTarget
forall a b. (a -> b) -> a -> b
$ ExeTarget :: HsFilePath
-> [FilePath]
-> Language
-> [ModuleName]
-> [Extension]
-> [Dependency]
-> [Dependency]
-> ExeTarget
ExeTarget
      { _exeMainIs :: HsFilePath
_exeMainIs = HsFilePath
-> (FilePath -> HsFilePath) -> Flag FilePath -> HsFilePath
forall b a. b -> (a -> b) -> Flag a -> b
flagElim HsFilePath
defaultMainIs FilePath -> HsFilePath
toHsFilePath (Flag FilePath -> HsFilePath) -> Flag FilePath -> HsFilePath
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag FilePath
mainIs InitFlags
flags
      , _exeApplicationDirs :: [FilePath]
_exeApplicationDirs  =
        [FilePath] -> Flag [FilePath] -> [FilePath]
forall a. a -> Flag a -> a
fromFlagOrDefault [FilePath
defaultApplicationDir] (Flag [FilePath] -> [FilePath]) -> Flag [FilePath] -> [FilePath]
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [FilePath]
applicationDirs InitFlags
flags
      , _exeLanguage :: Language
_exeLanguage = Language -> Flag Language -> Language
forall a. a -> Flag a -> a
fromFlagOrDefault Language
defaultLanguage (Flag Language -> Language) -> Flag Language -> Language
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag Language
language InitFlags
flags
      , _exeOtherModules :: [ModuleName]
_exeOtherModules = [ModuleName] -> Flag [ModuleName] -> [ModuleName]
forall a. a -> Flag a -> a
fromFlagOrDefault [] (Flag [ModuleName] -> [ModuleName])
-> Flag [ModuleName] -> [ModuleName]
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [ModuleName]
otherModules InitFlags
flags
      , _exeOtherExts :: [Extension]
_exeOtherExts = [Extension] -> Flag [Extension] -> [Extension]
forall a. a -> Flag a -> a
fromFlagOrDefault [] (Flag [Extension] -> [Extension])
-> Flag [Extension] -> [Extension]
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [Extension]
otherExts InitFlags
flags
      , _exeDependencies :: [Dependency]
_exeDependencies = [Dependency] -> Flag [Dependency] -> [Dependency]
forall a. a -> Flag a -> a
fromFlagOrDefault [] (Flag [Dependency] -> [Dependency])
-> Flag [Dependency] -> [Dependency]
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [Dependency]
dependencies InitFlags
flags
      , _exeBuildTools :: [Dependency]
_exeBuildTools = [Dependency]
buildToolDeps
      }

genSimpleTestTarget :: Interactive m => InitFlags -> m (Maybe TestTarget)
genSimpleTestTarget :: InitFlags -> m (Maybe TestTarget)
genSimpleTestTarget InitFlags
flags = Bool -> m (Maybe TestTarget)
forall (m :: * -> *). Interactive m => Bool -> m (Maybe TestTarget)
go (Bool -> m (Maybe TestTarget)) -> m Bool -> m (Maybe TestTarget)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< InitFlags -> m Bool
forall (m :: * -> *). Interactive m => InitFlags -> m Bool
initializeTestSuitePrompt InitFlags
flags
  where
    go :: Bool -> m (Maybe TestTarget)
go Bool
initialized
      | Bool -> Bool
not Bool
initialized = Maybe TestTarget -> m (Maybe TestTarget)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TestTarget
forall a. Maybe a
Nothing
      | Bool
otherwise = do
        [Dependency]
buildToolDeps <- InitFlags -> m [Dependency]
forall (m :: * -> *). Interactive m => InitFlags -> m [Dependency]
getBuildTools InitFlags
flags
        Maybe TestTarget -> m (Maybe TestTarget)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe TestTarget -> m (Maybe TestTarget))
-> Maybe TestTarget -> m (Maybe TestTarget)
forall a b. (a -> b) -> a -> b
$ TestTarget -> Maybe TestTarget
forall a. a -> Maybe a
Just (TestTarget -> Maybe TestTarget) -> TestTarget -> Maybe TestTarget
forall a b. (a -> b) -> a -> b
$ TestTarget :: HsFilePath
-> [FilePath]
-> Language
-> [ModuleName]
-> [Extension]
-> [Dependency]
-> [Dependency]
-> TestTarget
TestTarget
          { _testMainIs :: HsFilePath
_testMainIs = HsFilePath
-> (FilePath -> HsFilePath) -> Flag FilePath -> HsFilePath
forall b a. b -> (a -> b) -> Flag a -> b
flagElim HsFilePath
defaultMainIs FilePath -> HsFilePath
toHsFilePath (Flag FilePath -> HsFilePath) -> Flag FilePath -> HsFilePath
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag FilePath
mainIs InitFlags
flags
          , _testDirs :: [FilePath]
_testDirs  = [FilePath] -> Flag [FilePath] -> [FilePath]
forall a. a -> Flag a -> a
fromFlagOrDefault [FilePath
defaultTestDir] (Flag [FilePath] -> [FilePath]) -> Flag [FilePath] -> [FilePath]
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [FilePath]
testDirs InitFlags
flags
          , _testLanguage :: Language
_testLanguage = Language -> Flag Language -> Language
forall a. a -> Flag a -> a
fromFlagOrDefault Language
defaultLanguage (Flag Language -> Language) -> Flag Language -> Language
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag Language
language InitFlags
flags
          , _testOtherModules :: [ModuleName]
_testOtherModules = [ModuleName] -> Flag [ModuleName] -> [ModuleName]
forall a. a -> Flag a -> a
fromFlagOrDefault [] (Flag [ModuleName] -> [ModuleName])
-> Flag [ModuleName] -> [ModuleName]
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [ModuleName]
otherModules InitFlags
flags
          , _testOtherExts :: [Extension]
_testOtherExts = [Extension] -> Flag [Extension] -> [Extension]
forall a. a -> Flag a -> a
fromFlagOrDefault [] (Flag [Extension] -> [Extension])
-> Flag [Extension] -> [Extension]
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [Extension]
otherExts InitFlags
flags
          , _testDependencies :: [Dependency]
_testDependencies = [Dependency] -> Flag [Dependency] -> [Dependency]
forall a. a -> Flag a -> a
fromFlagOrDefault [] (Flag [Dependency] -> [Dependency])
-> Flag [Dependency] -> [Dependency]
forall a b. (a -> b) -> a -> b
$ InitFlags -> Flag [Dependency]
dependencies InitFlags
flags
          , _testBuildTools :: [Dependency]
_testBuildTools = [Dependency]
buildToolDeps
          }

-- -------------------------------------------------------------------- --
-- Utils

-- | If deps are defined, and base is present, we skip the search for base.
-- otherwise, we look up @base@ and add it to the list.
addBaseDepToFlags :: Interactive m => InstalledPackageIndex -> InitFlags -> m InitFlags
addBaseDepToFlags :: InstalledPackageIndex -> InitFlags -> m InitFlags
addBaseDepToFlags InstalledPackageIndex
pkgIx InitFlags
initFlags = case InitFlags -> Flag [Dependency]
dependencies InitFlags
initFlags of
  Flag [Dependency]
as
    | (Dependency -> Bool) -> [Dependency] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (FilePath -> FilePath -> Bool
forall a. Eq a => a -> a -> Bool
(==) FilePath
"base" (FilePath -> Bool)
-> (Dependency -> FilePath) -> Dependency -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageName -> FilePath
unPackageName (PackageName -> FilePath)
-> (Dependency -> PackageName) -> Dependency -> FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Dependency -> PackageName
depPkgName) [Dependency]
as -> InitFlags -> m InitFlags
forall (m :: * -> *) a. Monad m => a -> m a
return InitFlags
initFlags
    | Bool
otherwise -> do
      [Dependency]
based <- InstalledPackageIndex -> InitFlags -> m [Dependency]
forall (m :: * -> *).
Interactive m =>
InstalledPackageIndex -> InitFlags -> m [Dependency]
dependenciesPrompt InstalledPackageIndex
pkgIx InitFlags
initFlags
      InitFlags -> m InitFlags
forall (m :: * -> *) a. Monad m => a -> m a
return (InitFlags -> m InitFlags) -> InitFlags -> m InitFlags
forall a b. (a -> b) -> a -> b
$ InitFlags
initFlags
        { dependencies :: Flag [Dependency]
dependencies = [Dependency] -> Flag [Dependency]
forall a. a -> Flag a
Flag ([Dependency] -> Flag [Dependency])
-> [Dependency] -> Flag [Dependency]
forall a b. (a -> b) -> a -> b
$ [Dependency]
based [Dependency] -> [Dependency] -> [Dependency]
forall a. [a] -> [a] -> [a]
++ [Dependency]
as
        }
  Flag [Dependency]
_ -> do
    [Dependency]
based <- InstalledPackageIndex -> InitFlags -> m [Dependency]
forall (m :: * -> *).
Interactive m =>
InstalledPackageIndex -> InitFlags -> m [Dependency]
dependenciesPrompt InstalledPackageIndex
pkgIx InitFlags
initFlags
    InitFlags -> m InitFlags
forall (m :: * -> *) a. Monad m => a -> m a
return InitFlags
initFlags { dependencies :: Flag [Dependency]
dependencies = [Dependency] -> Flag [Dependency]
forall a. a -> Flag a
Flag [Dependency]
based }