{-# LANGUAGE PatternSynonyms #-}
module Distribution.Client.CmdHaddockProject
( haddockProjectCommand
, haddockProjectAction
) where
import Control.Monad (mapM)
import Distribution.Client.Compat.Prelude hiding (get)
import Prelude ()
import qualified Distribution.Client.CmdBuild as CmdBuild
import qualified Distribution.Client.CmdHaddock as CmdHaddock
import Distribution.Client.DistDirLayout
( CabalDirLayout (..)
, StoreDirLayout (..)
, distBuildDirectory
)
import Distribution.Client.InstallPlan (foldPlanPackage)
import qualified Distribution.Client.InstallPlan as InstallPlan
import qualified Distribution.Client.NixStyleOptions as NixStyleOptions
import Distribution.Client.ProjectOrchestration
( AvailableTarget (..)
, AvailableTargetStatus (..)
, CurrentCommand (..)
, ProjectBaseContext (..)
, ProjectBuildContext (..)
, TargetSelector (..)
, pruneInstallPlanToTargets
, resolveTargetsFromSolver
, runProjectPreBuildPhase
, selectComponentTargetBasic
)
import Distribution.Client.ProjectPlanning
( ElaboratedConfiguredPackage (..)
, ElaboratedInstallPlan
, ElaboratedSharedConfig (..)
, TargetAction (..)
)
import Distribution.Client.ProjectPlanning.Types
( elabDistDirParams
)
import Distribution.Client.ScriptUtils
( AcceptNoTargets (..)
, TargetContext (..)
, updateContextAndWriteProjectFile
, withContextAndSelectors
)
import Distribution.Client.Setup
( CommonSetupFlags (setupVerbosity)
, ConfigFlags (..)
, GlobalFlags (..)
)
import Distribution.Client.TargetProblem (TargetProblem (..))
import Distribution.Simple.BuildPaths
( haddockBenchmarkDirPath
, haddockDirName
, haddockLibraryDirPath
, haddockLibraryPath
, haddockPath
, haddockTestDirPath
)
import Distribution.Simple.Command
( CommandUI (..)
)
import Distribution.Simple.Flag
( fromFlag
, fromFlagOrDefault
, pattern Flag
, pattern NoFlag
)
import Distribution.Simple.Haddock (createHaddockIndex)
import Distribution.Simple.InstallDirs
( toPathTemplate
)
import Distribution.Simple.Program.Builtin
( haddockProgram
)
import Distribution.Simple.Program.Db
( addKnownProgram
, reconfigurePrograms
, requireProgramVersion
)
import Distribution.Simple.Setup
( HaddockFlags (..)
, HaddockProjectFlags (..)
, HaddockTarget (..)
, Visibility (..)
, defaultHaddockFlags
, haddockProjectCommand
)
import Distribution.Simple.Utils
( copyDirectoryRecursive
, createDirectoryIfMissingVerbose
, dieWithException
, info
, warn
)
import Distribution.Types.InstalledPackageInfo (InstalledPackageInfo (..))
import Distribution.Types.PackageDescription (PackageDescription (benchmarks, subLibraries, testSuites))
import Distribution.Types.PackageId (pkgName)
import Distribution.Types.PackageName (unPackageName)
import Distribution.Types.UnitId (unUnitId)
import Distribution.Types.Version (mkVersion)
import Distribution.Types.VersionRange (orLaterVersion)
import Distribution.Verbosity as Verbosity
( normal
)
import Distribution.Client.Errors
import System.Directory (doesDirectoryExist, doesFileExist)
import System.FilePath (normalise, takeDirectory, (</>))
haddockProjectAction :: HaddockProjectFlags -> [String] -> GlobalFlags -> IO ()
haddockProjectAction :: HaddockProjectFlags -> [[Char]] -> GlobalFlags -> IO ()
haddockProjectAction HaddockProjectFlags
flags [[Char]]
_extraArgs GlobalFlags
globalFlags = do
let outputDir :: [Char]
outputDir = [Char] -> [Char]
normalise ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ Flag [Char] -> [Char]
forall a. WithCallStack (Flag a -> a)
fromFlag (HaddockProjectFlags -> Flag [Char]
haddockProjectDir HaddockProjectFlags
flags)
Verbosity -> Bool -> [Char] -> IO ()
createDirectoryIfMissingVerbose Verbosity
verbosity Bool
True [Char]
outputDir
Verbosity -> [Char] -> IO ()
warn Verbosity
verbosity [Char]
"haddock-project command is experimental, it might break in the future"
Verbosity
-> AcceptNoTargets
-> Maybe ComponentKind
-> NixStyleFlags BuildFlags
-> [[Char]]
-> GlobalFlags
-> CurrentCommand
-> (TargetContext
-> ProjectBaseContext -> [TargetSelector] -> IO ())
-> IO ()
forall a b.
Verbosity
-> AcceptNoTargets
-> Maybe ComponentKind
-> NixStyleFlags a
-> [[Char]]
-> GlobalFlags
-> CurrentCommand
-> (TargetContext
-> ProjectBaseContext -> [TargetSelector] -> IO b)
-> IO b
withContextAndSelectors
Verbosity
verbosity
AcceptNoTargets
RejectNoTargets
Maybe ComponentKind
forall a. Maybe a
Nothing
(CommandUI (NixStyleFlags BuildFlags) -> NixStyleFlags BuildFlags
forall flags. CommandUI flags -> flags
commandDefaultFlags CommandUI (NixStyleFlags BuildFlags)
CmdBuild.buildCommand)
[[Char]
"all"]
GlobalFlags
globalFlags
CurrentCommand
HaddockCommand
((TargetContext -> ProjectBaseContext -> [TargetSelector] -> IO ())
-> IO ())
-> (TargetContext
-> ProjectBaseContext -> [TargetSelector] -> IO ())
-> IO ()
forall a b. (a -> b) -> a -> b
$ \TargetContext
targetCtx ProjectBaseContext
ctx [TargetSelector]
targetSelectors -> do
baseCtx <- case TargetContext
targetCtx of
TargetContext
ProjectContext -> ProjectBaseContext -> IO ProjectBaseContext
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectBaseContext
ctx
TargetContext
GlobalContext -> ProjectBaseContext -> IO ProjectBaseContext
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjectBaseContext
ctx
ScriptContext [Char]
path Executable
exemeta -> ProjectBaseContext -> [Char] -> Executable -> IO ProjectBaseContext
updateContextAndWriteProjectFile ProjectBaseContext
ctx [Char]
path Executable
exemeta
let distLayout = ProjectBaseContext -> DistDirLayout
distDirLayout ProjectBaseContext
baseCtx
cabalLayout = ProjectBaseContext -> CabalDirLayout
cabalDirLayout ProjectBaseContext
baseCtx
buildCtx <-
runProjectPreBuildPhase verbosity baseCtx $ \ElaboratedInstallPlan
elaboratedPlan -> do
targets <-
([TargetProblem ()] -> IO TargetsMap)
-> (TargetsMap -> IO TargetsMap)
-> Either [TargetProblem ()] TargetsMap
-> IO TargetsMap
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either [TargetProblem ()] -> IO TargetsMap
forall x a. Show x => [x] -> IO a
reportTargetProblems TargetsMap -> IO TargetsMap
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either [TargetProblem ()] TargetsMap -> IO TargetsMap)
-> Either [TargetProblem ()] TargetsMap -> IO TargetsMap
forall a b. (a -> b) -> a -> b
$
(forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem ()) [k])
-> (forall k.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem ()) k)
-> ElaboratedInstallPlan
-> Maybe SourcePackageDb
-> [TargetSelector]
-> Either [TargetProblem ()] 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 ()) [k]
forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem ()) [k]
selectPackageTargets
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem ()) k
forall k.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem ()) k
forall k a.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem a) k
selectComponentTargetBasic
ElaboratedInstallPlan
elaboratedPlan
Maybe SourcePackageDb
forall a. Maybe a
Nothing
[TargetSelector]
targetSelectors
let elaboratedPlan' =
TargetAction
-> TargetsMap -> ElaboratedInstallPlan -> ElaboratedInstallPlan
pruneInstallPlanToTargets
TargetAction
TargetActionBuild
TargetsMap
targets
ElaboratedInstallPlan
elaboratedPlan
return (elaboratedPlan', targets)
let elaboratedPlan :: ElaboratedInstallPlan
elaboratedPlan = ProjectBuildContext -> ElaboratedInstallPlan
elaboratedPlanOriginal ProjectBuildContext
buildCtx
sharedConfig :: ElaboratedSharedConfig
sharedConfig = ProjectBuildContext -> ElaboratedSharedConfig
elaboratedShared ProjectBuildContext
buildCtx
pkgs :: [Either InstalledPackageInfo ElaboratedConfiguredPackage]
pkgs = ElaboratedInstallPlan
-> [Either InstalledPackageInfo ElaboratedConfiguredPackage]
matchingPackages ElaboratedInstallPlan
elaboratedPlan
progs <-
reconfigurePrograms
verbosity
(haddockProjectProgramPaths flags)
(haddockProjectProgramArgs flags)
. addKnownProgram haddockProgram
. pkgConfigCompilerProgs
$ sharedConfig
let sharedConfig' = ElaboratedSharedConfig
sharedConfig{pkgConfigCompilerProgs = progs}
_ <-
requireProgramVersion
verbosity
haddockProgram
(orLaterVersion (mkVersion [2, 26, 1]))
progs
when localStyle $
CmdBuild.buildAction
(commandDefaultFlags CmdBuild.buildCommand)
["all"]
globalFlags
CmdHaddock.haddockAction
nixFlags
["all"]
globalFlags
packageInfos <- fmap (nub . concat) $ for pkgs $ \Either InstalledPackageInfo ElaboratedConfiguredPackage
pkg ->
case Either InstalledPackageInfo ElaboratedConfiguredPackage
pkg of
Left InstalledPackageInfo
package | Bool
localStyle -> do
let packageName :: [Char]
packageName = PackageName -> [Char]
unPackageName (PackageIdentifier -> PackageName
pkgName (PackageIdentifier -> PackageName)
-> PackageIdentifier -> PackageName
forall a b. (a -> b) -> a -> b
$ InstalledPackageInfo -> PackageIdentifier
sourcePackageId InstalledPackageInfo
package)
destDir :: [Char]
destDir = [Char]
outputDir [Char] -> [Char] -> [Char]
</> [Char]
packageName
([Maybe (Either [Char] ([Char], [Char], Visibility))]
-> [Either [Char] ([Char], [Char], Visibility)])
-> IO [Maybe (Either [Char] ([Char], [Char], Visibility))]
-> IO [Either [Char] ([Char], [Char], Visibility)]
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Maybe (Either [Char] ([Char], [Char], Visibility))]
-> [Either [Char] ([Char], [Char], Visibility)]
forall a. [Maybe a] -> [a]
catMaybes (IO [Maybe (Either [Char] ([Char], [Char], Visibility))]
-> IO [Either [Char] ([Char], [Char], Visibility)])
-> IO [Maybe (Either [Char] ([Char], [Char], Visibility))]
-> IO [Either [Char] ([Char], [Char], Visibility)]
forall a b. (a -> b) -> a -> b
$ [[Char]]
-> ([Char]
-> IO (Maybe (Either [Char] ([Char], [Char], Visibility))))
-> IO [Maybe (Either [Char] ([Char], [Char], Visibility))]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (InstalledPackageInfo -> [[Char]]
haddockInterfaces InstalledPackageInfo
package) (([Char]
-> IO (Maybe (Either [Char] ([Char], [Char], Visibility))))
-> IO [Maybe (Either [Char] ([Char], [Char], Visibility))])
-> ([Char]
-> IO (Maybe (Either [Char] ([Char], [Char], Visibility))))
-> IO [Maybe (Either [Char] ([Char], [Char], Visibility))]
forall a b. (a -> b) -> a -> b
$ \[Char]
interfacePath -> do
let docDir :: [Char]
docDir = [Char] -> [Char]
takeDirectory [Char]
interfacePath
a <- [Char] -> IO Bool
doesFileExist [Char]
interfacePath
case a of
Bool
True -> do
Verbosity -> [Char] -> [Char] -> IO ()
copyDirectoryRecursive Verbosity
verbosity [Char]
docDir [Char]
destDir
Maybe (Either [Char] ([Char], [Char], Visibility))
-> IO (Maybe (Either [Char] ([Char], [Char], Visibility)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Either [Char] ([Char], [Char], Visibility))
-> IO (Maybe (Either [Char] ([Char], [Char], Visibility))))
-> Maybe (Either [Char] ([Char], [Char], Visibility))
-> IO (Maybe (Either [Char] ([Char], [Char], Visibility)))
forall a b. (a -> b) -> a -> b
$ Either [Char] ([Char], [Char], Visibility)
-> Maybe (Either [Char] ([Char], [Char], Visibility))
forall a. a -> Maybe a
Just (Either [Char] ([Char], [Char], Visibility)
-> Maybe (Either [Char] ([Char], [Char], Visibility)))
-> Either [Char] ([Char], [Char], Visibility)
-> Maybe (Either [Char] ([Char], [Char], Visibility))
forall a b. (a -> b) -> a -> b
$ ([Char], [Char], Visibility)
-> Either [Char] ([Char], [Char], Visibility)
forall a b. b -> Either a b
Right ([Char]
packageName, [Char]
interfacePath, Visibility
Hidden)
Bool
False -> Maybe (Either [Char] ([Char], [Char], Visibility))
-> IO (Maybe (Either [Char] ([Char], [Char], Visibility)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Either [Char] ([Char], [Char], Visibility))
forall a. Maybe a
Nothing
Left InstalledPackageInfo
_ -> [Either [Char] ([Char], [Char], Visibility)]
-> IO [Either [Char] ([Char], [Char], Visibility)]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return []
Right ElaboratedConfiguredPackage
package ->
case ElaboratedConfiguredPackage -> Bool
elabLocalToProject ElaboratedConfiguredPackage
package of
Bool
True -> do
let distDirParams :: DistDirParams
distDirParams = ElaboratedSharedConfig
-> ElaboratedConfiguredPackage -> DistDirParams
elabDistDirParams ElaboratedSharedConfig
sharedConfig' ElaboratedConfiguredPackage
package
pkg_descr :: PackageDescription
pkg_descr = ElaboratedConfiguredPackage -> PackageDescription
elabPkgDescription ElaboratedConfiguredPackage
package
packageName :: PackageName
packageName = PackageIdentifier -> PackageName
pkgName (PackageIdentifier -> PackageName)
-> PackageIdentifier -> PackageName
forall a b. (a -> b) -> a -> b
$ ElaboratedConfiguredPackage -> PackageIdentifier
elabPkgSourceId ElaboratedConfiguredPackage
package
unitId :: UnitId
unitId = ElaboratedConfiguredPackage -> UnitId
elabUnitId ElaboratedConfiguredPackage
package
packageDir :: [Char]
packageDir = HaddockTarget -> PackageDescription -> [Char]
haddockDirName HaddockTarget
ForDevelopment PackageDescription
pkg_descr
destDir :: [Char]
destDir = [Char]
outputDir [Char] -> [Char] -> [Char]
</> [Char]
packageDir
interfacePath :: [Char]
interfacePath = [Char]
destDir [Char] -> [Char] -> [Char]
</> PackageDescription -> [Char]
haddockPath PackageDescription
pkg_descr
buildDir :: [Char]
buildDir = DistDirLayout -> DistDirParams -> [Char]
distBuildDirectory DistDirLayout
distLayout DistDirParams
distDirParams
docDir :: [Char]
docDir =
[Char]
buildDir
[Char] -> [Char] -> [Char]
</> [Char]
"doc"
[Char] -> [Char] -> [Char]
</> [Char]
"html"
[Char] -> [Char] -> [Char]
</> [Char]
packageDir
a <- [Char] -> IO Bool
doesDirectoryExist [Char]
docDir
if a
then do
copyDirectoryRecursive verbosity docDir destDir
let infos :: [(String, FilePath, Visibility)]
infos =
(PackageName -> [Char]
unPackageName PackageName
packageName, [Char]
interfacePath, Visibility
Visible)
([Char], [Char], Visibility)
-> [([Char], [Char], Visibility)] -> [([Char], [Char], Visibility)]
forall a. a -> [a] -> [a]
: [ ([Char]
sublibDirPath, [Char]
sublibInterfacePath, Visibility
Visible)
| Library
lib <- PackageDescription -> [Library]
subLibraries PackageDescription
pkg_descr
, let sublibDirPath :: [Char]
sublibDirPath = HaddockTarget -> PackageDescription -> Library -> [Char]
haddockLibraryDirPath HaddockTarget
ForDevelopment PackageDescription
pkg_descr Library
lib
sublibInterfacePath :: [Char]
sublibInterfacePath =
[Char]
outputDir
[Char] -> [Char] -> [Char]
</> [Char]
sublibDirPath
[Char] -> [Char] -> [Char]
</> PackageDescription -> Library -> [Char]
haddockLibraryPath PackageDescription
pkg_descr Library
lib
]
[([Char], [Char], Visibility)]
-> [([Char], [Char], Visibility)] -> [([Char], [Char], Visibility)]
forall a. [a] -> [a] -> [a]
++ [ ([Char]
testPath, [Char]
testInterfacePath, Visibility
Visible)
| TestSuite
test <- PackageDescription -> [TestSuite]
testSuites PackageDescription
pkg_descr
, let testPath :: [Char]
testPath = HaddockTarget -> PackageDescription -> TestSuite -> [Char]
haddockTestDirPath HaddockTarget
ForDevelopment PackageDescription
pkg_descr TestSuite
test
testInterfacePath :: [Char]
testInterfacePath =
[Char]
outputDir
[Char] -> [Char] -> [Char]
</> [Char]
testPath
[Char] -> [Char] -> [Char]
</> PackageDescription -> [Char]
haddockPath PackageDescription
pkg_descr
]
[([Char], [Char], Visibility)]
-> [([Char], [Char], Visibility)] -> [([Char], [Char], Visibility)]
forall a. [a] -> [a] -> [a]
++ [ ([Char]
benchPath, [Char]
benchInterfacePath, Visibility
Visible)
| Benchmark
bench <- PackageDescription -> [Benchmark]
benchmarks PackageDescription
pkg_descr
, let benchPath :: [Char]
benchPath = HaddockTarget -> PackageDescription -> Benchmark -> [Char]
haddockBenchmarkDirPath HaddockTarget
ForDevelopment PackageDescription
pkg_descr Benchmark
bench
benchInterfacePath :: [Char]
benchInterfacePath =
[Char]
outputDir
[Char] -> [Char] -> [Char]
</> [Char]
benchPath
[Char] -> [Char] -> [Char]
</> PackageDescription -> [Char]
haddockPath PackageDescription
pkg_descr
]
infos' <-
mapM
( \x :: ([Char], [Char], Visibility)
x@([Char]
_, [Char]
path, Visibility
_) -> do
e <- [Char] -> IO Bool
doesFileExist [Char]
path
return $
if e
then Right x
else Left path
)
infos
return infos'
else do
warn
verbosity
( "haddocks of "
++ unUnitId unitId
++ " not found in the store"
)
return []
Bool
False
| Bool -> Bool
not Bool
localStyle ->
[Either [Char] ([Char], [Char], Visibility)]
-> IO [Either [Char] ([Char], [Char], Visibility)]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return []
Bool
False -> do
let pkg_descr :: PackageDescription
pkg_descr = ElaboratedConfiguredPackage -> PackageDescription
elabPkgDescription ElaboratedConfiguredPackage
package
unitId :: [Char]
unitId = UnitId -> [Char]
unUnitId (ElaboratedConfiguredPackage -> UnitId
elabUnitId ElaboratedConfiguredPackage
package)
packageDir :: [Char]
packageDir =
StoreDirLayout -> Compiler -> UnitId -> [Char]
storePackageDirectory
(CabalDirLayout -> StoreDirLayout
cabalStoreDirLayout CabalDirLayout
cabalLayout)
(ElaboratedSharedConfig -> Compiler
pkgConfigCompiler ElaboratedSharedConfig
sharedConfig')
(ElaboratedConfiguredPackage -> UnitId
elabUnitId ElaboratedConfiguredPackage
package)
docDir :: [Char]
docDir = [Char]
packageDir [Char] -> [Char] -> [Char]
</> [Char]
"share" [Char] -> [Char] -> [Char]
</> [Char]
"doc" [Char] -> [Char] -> [Char]
</> [Char]
"html"
destDir :: [Char]
destDir = [Char]
outputDir [Char] -> [Char] -> [Char]
</> HaddockTarget -> PackageDescription -> [Char]
haddockDirName HaddockTarget
ForDevelopment PackageDescription
pkg_descr
interfacePath :: [Char]
interfacePath = [Char]
destDir [Char] -> [Char] -> [Char]
</> PackageDescription -> [Char]
haddockPath PackageDescription
pkg_descr
a <- [Char] -> IO Bool
doesDirectoryExist [Char]
docDir
case a of
Bool
True -> do
Verbosity -> [Char] -> [Char] -> IO ()
copyDirectoryRecursive Verbosity
verbosity [Char]
docDir [Char]
destDir
[Either [Char] ([Char], [Char], Visibility)]
-> IO [Either [Char] ([Char], [Char], Visibility)]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [([Char], [Char], Visibility)
-> Either [Char] ([Char], [Char], Visibility)
forall a b. b -> Either a b
Right ([Char]
unitId, [Char]
interfacePath, Visibility
Hidden)]
Bool
False -> do
[Either [Char] ([Char], [Char], Visibility)]
-> IO [Either [Char] ([Char], [Char], Visibility)]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [[Char] -> Either [Char] ([Char], [Char], Visibility)
forall a b. a -> Either a b
Left [Char]
unitId]
let (missingHaddocks, packageInfos') = partitionEithers packageInfos
when (not (null missingHaddocks)) $ do
warn verbosity "missing haddocks for some packages from the store"
info verbosity (intercalate "\n" missingHaddocks)
let flags' =
HaddockProjectFlags
flags
{ haddockProjectDir = Flag outputDir
, haddockProjectInterfaces =
Flag
[ ( interfacePath
, Just url
, Just url
, visibility
)
| (url, interfacePath, visibility) <- packageInfos'
]
, haddockProjectUseUnicode = NoFlag
}
createHaddockIndex
verbosity
(pkgConfigCompilerProgs sharedConfig')
(pkgConfigCompiler sharedConfig')
(pkgConfigPlatform sharedConfig')
Nothing
flags'
where
commonFlags :: CommonSetupFlags
commonFlags = HaddockProjectFlags -> CommonSetupFlags
haddockProjectCommonFlags HaddockProjectFlags
flags
verbosity :: Verbosity
verbosity = Verbosity -> Flag Verbosity -> Verbosity
forall a. a -> Flag a -> a
fromFlagOrDefault Verbosity
normal (CommonSetupFlags -> Flag Verbosity
setupVerbosity CommonSetupFlags
commonFlags)
haddockFlags :: HaddockFlags
haddockFlags =
HaddockFlags
defaultHaddockFlags
{ haddockCommonFlags = commonFlags
, haddockHtml = Flag True
,
haddockBaseUrl =
if localStyle
then Flag ".."
else NoFlag
, haddockProgramPaths = haddockProjectProgramPaths flags
, haddockProgramArgs = haddockProjectProgramArgs flags
, haddockHtmlLocation =
if fromFlagOrDefault False (haddockProjectHackage flags)
then Flag "https://hackage.haskell.org/package/$pkg-$version/docs"
else haddockProjectHtmlLocation flags
, haddockHoogle = haddockProjectHoogle flags
, haddockExecutables = haddockProjectExecutables flags
, haddockTestSuites = haddockProjectTestSuites flags
, haddockBenchmarks = haddockProjectBenchmarks flags
, haddockForeignLibs = haddockProjectForeignLibs flags
, haddockInternal = haddockProjectInternal flags
, haddockCss = haddockProjectCss flags
, haddockLinkedSource = Flag True
, haddockQuickJump = Flag True
, haddockHscolourCss = haddockProjectHscolourCss flags
, haddockContents =
if localStyle
then Flag (toPathTemplate "../index.html")
else NoFlag
, haddockIndex =
if localStyle
then Flag (toPathTemplate "../doc-index.html")
else NoFlag
, haddockResourcesDir = haddockProjectResourcesDir flags
, haddockUseUnicode = haddockProjectUseUnicode flags
}
nixFlags :: NixStyleFlags ClientHaddockFlags
nixFlags =
(CommandUI (NixStyleFlags ClientHaddockFlags)
-> NixStyleFlags ClientHaddockFlags
forall flags. CommandUI flags -> flags
commandDefaultFlags CommandUI (NixStyleFlags ClientHaddockFlags)
CmdHaddock.haddockCommand)
{ NixStyleOptions.haddockFlags = haddockFlags
, NixStyleOptions.configFlags =
(NixStyleOptions.configFlags (commandDefaultFlags CmdBuild.buildCommand))
{ configCommonFlags = commonFlags
}
}
localStyle :: Bool
localStyle =
let hackage :: Bool
hackage = Bool -> Last Bool -> Bool
forall a. a -> Flag a -> a
fromFlagOrDefault Bool
False (HaddockProjectFlags -> Last Bool
haddockProjectHackage HaddockProjectFlags
flags)
location :: Bool
location = Bool -> Last Bool -> Bool
forall a. a -> Flag a -> a
fromFlagOrDefault Bool
False (Bool -> [Char] -> Bool
forall a b. a -> b -> a
const Bool
True ([Char] -> Bool) -> Flag [Char] -> Last Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HaddockProjectFlags -> Flag [Char]
haddockProjectHtmlLocation HaddockProjectFlags
flags)
in Bool -> Bool
not Bool
hackage Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
location
reportTargetProblems :: Show x => [x] -> IO a
reportTargetProblems :: forall x a. Show x => [x] -> IO a
reportTargetProblems =
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)
-> ([x] -> CabalInstallException) -> [x] -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> CabalInstallException
CmdHaddockReportTargetProblems ([[Char]] -> CabalInstallException)
-> ([x] -> [[Char]]) -> [x] -> CabalInstallException
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (x -> [Char]) -> [x] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map x -> [Char]
forall a. Show a => a -> [Char]
show
selectPackageTargets
:: TargetSelector
-> [AvailableTarget k]
-> Either (TargetProblem ()) [k]
selectPackageTargets :: forall k.
TargetSelector
-> [AvailableTarget k] -> Either (TargetProblem ()) [k]
selectPackageTargets TargetSelector
_ [AvailableTarget k]
ts =
[k] -> Either (TargetProblem ()) [k]
forall a b. b -> Either a b
Right ([k] -> Either (TargetProblem ()) [k])
-> [k] -> Either (TargetProblem ()) [k]
forall a b. (a -> b) -> a -> b
$
(AvailableTarget k -> Maybe k) -> [AvailableTarget k] -> [k]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe
( \AvailableTarget k
t -> case AvailableTarget k -> AvailableTargetStatus k
forall k. AvailableTarget k -> AvailableTargetStatus k
availableTargetStatus AvailableTarget k
t of
TargetBuildable k
k TargetRequested
_
| AvailableTarget k -> Bool
forall k. AvailableTarget k -> Bool
availableTargetLocalToProject AvailableTarget k
t ->
k -> Maybe k
forall a. a -> Maybe a
Just k
k
AvailableTargetStatus k
_ -> Maybe k
forall a. Maybe a
Nothing
)
[AvailableTarget k]
ts
matchingPackages
:: ElaboratedInstallPlan
-> [Either InstalledPackageInfo ElaboratedConfiguredPackage]
matchingPackages :: ElaboratedInstallPlan
-> [Either InstalledPackageInfo ElaboratedConfiguredPackage]
matchingPackages =
(GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage
-> Either InstalledPackageInfo ElaboratedConfiguredPackage)
-> [GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage]
-> [Either InstalledPackageInfo ElaboratedConfiguredPackage]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((InstalledPackageInfo
-> Either InstalledPackageInfo ElaboratedConfiguredPackage)
-> (ElaboratedConfiguredPackage
-> Either InstalledPackageInfo ElaboratedConfiguredPackage)
-> GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage
-> Either InstalledPackageInfo ElaboratedConfiguredPackage
forall ipkg a srcpkg.
(ipkg -> a) -> (srcpkg -> a) -> GenericPlanPackage ipkg srcpkg -> a
foldPlanPackage InstalledPackageInfo
-> Either InstalledPackageInfo ElaboratedConfiguredPackage
forall a b. a -> Either a b
Left ElaboratedConfiguredPackage
-> Either InstalledPackageInfo ElaboratedConfiguredPackage
forall a b. b -> Either a b
Right)
([GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage]
-> [Either InstalledPackageInfo ElaboratedConfiguredPackage])
-> (ElaboratedInstallPlan
-> [GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage])
-> ElaboratedInstallPlan
-> [Either InstalledPackageInfo ElaboratedConfiguredPackage]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedInstallPlan
-> [GenericPlanPackage
InstalledPackageInfo ElaboratedConfiguredPackage]
forall ipkg srcpkg.
GenericInstallPlan ipkg srcpkg -> [GenericPlanPackage ipkg srcpkg]
InstallPlan.toList