{-# LANGUAGE RecordWildCards #-}

-- | Copyright: (c) 2020 berberman
-- SPDX-License-Identifier: MIT
-- Maintainer: berberman <1793913507@qq.com>
-- Stability: experimental
-- Portability: portable
-- The core functions of @arch-hs@.
module Distribution.ArchHs.Core
  ( getDependencies,
    cabalToPkgBuild,
    evalConditionTree,
  )
where

import qualified Algebra.Graph.Labelled.AdjacencyMap as G
import Data.List (stripPrefix)
import qualified Data.Map as Map
import Data.Set (Set)
import qualified Data.Set as Set
import Distribution.ArchHs.Hackage (getLatestCabal, getLatestSHA256)
import Distribution.ArchHs.Local (ghcLibList, ignoreList)
import Distribution.ArchHs.PkgBuild (PkgBuild (..), mapLicense)
import Distribution.ArchHs.Types
import Distribution.ArchHs.Utils
import Distribution.Compiler (CompilerFlavor (..))
import Distribution.PackageDescription
import Distribution.Pretty (prettyShow)
import Distribution.SPDX
import Distribution.System (Arch (X86_64), OS (Linux))
import qualified Distribution.Types.BuildInfo.Lens as L
import Distribution.Types.CondTree (simplifyCondTree)
import Distribution.Types.Dependency (Dependency)
import Distribution.Types.PackageName (PackageName, unPackageName)
import Distribution.Types.UnqualComponentName (UnqualComponentName, unqualComponentNameToPackageName)
import Distribution.Types.Version (mkVersion)
import Distribution.Types.VersionRange (VersionRange, withinRange)
import Distribution.Utils.ShortText (fromShortText)

archEnv :: FlagAssignment -> ConfVar -> Either ConfVar Bool
archEnv :: FlagAssignment -> ConfVar -> Either ConfVar Bool
archEnv FlagAssignment
_ (OS OS
Linux) = Bool -> Either ConfVar Bool
forall a b. b -> Either a b
Right Bool
True
archEnv FlagAssignment
_ (OS OS
_) = Bool -> Either ConfVar Bool
forall a b. b -> Either a b
Right Bool
False
archEnv FlagAssignment
_ (Arch Arch
X86_64) = Bool -> Either ConfVar Bool
forall a b. b -> Either a b
Right Bool
True
archEnv FlagAssignment
_ (Arch Arch
_) = Bool -> Either ConfVar Bool
forall a b. b -> Either a b
Right Bool
False
archEnv FlagAssignment
_ (Impl CompilerFlavor
GHC VersionRange
range) = Bool -> Either ConfVar Bool
forall a b. b -> Either a b
Right (Bool -> Either ConfVar Bool) -> Bool -> Either ConfVar Bool
forall a b. (a -> b) -> a -> b
$ Version -> VersionRange -> Bool
withinRange ([Int] -> Version
mkVersion [Int
8, Int
10, Int
2]) VersionRange
range
archEnv FlagAssignment
_ (Impl CompilerFlavor
_ VersionRange
_) = Bool -> Either ConfVar Bool
forall a b. b -> Either a b
Right Bool
False
archEnv FlagAssignment
assignment f :: ConfVar
f@(Flag FlagName
f') = ConfVar -> Maybe Bool -> Either ConfVar Bool
forall a b. a -> Maybe b -> Either a b
go ConfVar
f (Maybe Bool -> Either ConfVar Bool)
-> Maybe Bool -> Either ConfVar Bool
forall a b. (a -> b) -> a -> b
$ FlagName -> FlagAssignment -> Maybe Bool
lookupFlagAssignment FlagName
f' FlagAssignment
assignment
  where
    go :: a -> Maybe b -> Either a b
go a
_ (Just b
r) = b -> Either a b
forall a b. b -> Either a b
Right b
r
    go a
x Maybe b
Nothing = a -> Either a b
forall a b. a -> Either a b
Left a
x

-- | Simplify the condition tree from 'GenericPackageDescription' with given flag assignments and archlinux system assumption.
evalConditionTree ::
  (HasCallStack, Semigroup k, L.HasBuildInfo k, Members [FlagAssignmentsEnv, Trace] r) =>
  GenericPackageDescription ->
  CondTree ConfVar [Dependency] k ->
  Sem r BuildInfo
evalConditionTree :: GenericPackageDescription
-> CondTree ConfVar [Dependency] k -> Sem r BuildInfo
evalConditionTree GenericPackageDescription
cabal CondTree ConfVar [Dependency] k
cond = do
  Map PackageName FlagAssignment
flagAssignments <- Sem r (Map PackageName FlagAssignment)
forall i (r :: [Effect]). MemberWithError (Reader i) r => Sem r i
ask
  let name :: PackageName
name = GenericPackageDescription -> PackageName
getPkgName' GenericPackageDescription
cabal
      packageFlags :: [Flag]
packageFlags = GenericPackageDescription -> [Flag]
genPackageFlags GenericPackageDescription
cabal
      defaultFlagAssignments :: FlagAssignment
defaultFlagAssignments =
        (Flag -> FlagAssignment -> FlagAssignment)
-> FlagAssignment -> [Flag] -> FlagAssignment
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\Flag
f FlagAssignment
acc -> FlagName -> Bool -> FlagAssignment -> FlagAssignment
insertFlagAssignment (Flag -> FlagName
flagName Flag
f) (Flag -> Bool
flagDefault Flag
f) FlagAssignment
acc) ([(FlagName, Bool)] -> FlagAssignment
mkFlagAssignment []) [Flag]
packageFlags
      flagAssignment :: [(FlagName, Bool)]
flagAssignment = case PackageName
-> Map PackageName FlagAssignment -> Maybe FlagAssignment
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup PackageName
name Map PackageName FlagAssignment
flagAssignments of
        Just FlagAssignment
f -> FlagAssignment -> [(FlagName, Bool)]
unFlagAssignment FlagAssignment
f
        Maybe FlagAssignment
_ -> []
      flagNames :: [FlagName]
flagNames = ((FlagName, Bool) -> FlagName) -> [(FlagName, Bool)] -> [FlagName]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (FlagName, Bool) -> FlagName
forall a b. (a, b) -> a
fst [(FlagName, Bool)]
flagAssignment
      thisFlag :: FlagAssignment
thisFlag =
        [(FlagName, Bool)] -> FlagAssignment
mkFlagAssignment
          ([(FlagName, Bool)] -> FlagAssignment)
-> ([(FlagName, Bool)] -> [(FlagName, Bool)])
-> [(FlagName, Bool)]
-> FlagAssignment
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([(FlagName, Bool)] -> [(FlagName, Bool)] -> [(FlagName, Bool)]
forall a. Semigroup a => a -> a -> a
<> [(FlagName, Bool)]
flagAssignment)
          ([(FlagName, Bool)] -> [(FlagName, Bool)])
-> ([(FlagName, Bool)] -> [(FlagName, Bool)])
-> [(FlagName, Bool)]
-> [(FlagName, Bool)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((FlagName, Bool) -> Bool)
-> [(FlagName, Bool)] -> [(FlagName, Bool)]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(FlagName
fName, Bool
_) -> FlagName
fName FlagName -> [FlagName] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [FlagName]
flagNames)
          ([(FlagName, Bool)] -> FlagAssignment)
-> [(FlagName, Bool)] -> FlagAssignment
forall a b. (a -> b) -> a -> b
$ (FlagAssignment -> [(FlagName, Bool)]
unFlagAssignment FlagAssignment
defaultFlagAssignments)
  String -> Sem r ()
forall (r :: [Effect]).
MemberWithError Trace r =>
String -> Sem r ()
trace' (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ String
"Evaluating condition tree of " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> PackageName -> String
forall a. Show a => a -> String
show PackageName
name
  String -> Sem r ()
forall (r :: [Effect]).
MemberWithError Trace r =>
String -> Sem r ()
trace' (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ String
"Flags: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> FlagAssignment -> String
forall a. Show a => a -> String
show FlagAssignment
thisFlag
  Sem r ()
forall (r :: [Effect]).
(HasCallStack, MemberWithError Trace r) =>
Sem r ()
traceCallStack
  BuildInfo -> Sem r BuildInfo
forall (m :: * -> *) a. Monad m => a -> m a
return (BuildInfo -> Sem r BuildInfo) -> BuildInfo -> Sem r BuildInfo
forall a b. (a -> b) -> a -> b
$ (k -> Getting BuildInfo k BuildInfo -> BuildInfo
forall s a. s -> Getting a s a -> a
^. Getting BuildInfo k BuildInfo
forall a. HasBuildInfo a => Lens' a BuildInfo
L.buildInfo) (k -> BuildInfo)
-> (([Dependency], k) -> k) -> ([Dependency], k) -> BuildInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Dependency], k) -> k
forall a b. (a, b) -> b
snd (([Dependency], k) -> BuildInfo) -> ([Dependency], k) -> BuildInfo
forall a b. (a -> b) -> a -> b
$ (ConfVar -> Either ConfVar Bool)
-> CondTree ConfVar [Dependency] k -> ([Dependency], k)
forall a d v.
(Semigroup a, Semigroup d) =>
(v -> Either v Bool) -> CondTree v d a -> (d, a)
simplifyCondTree (FlagAssignment -> ConfVar -> Either ConfVar Bool
archEnv FlagAssignment
thisFlag) CondTree ConfVar [Dependency] k
cond

-----------------------------------------------------------------------------

-- | Get dependencies of a package recursively.
-- All version constraints will be discarded,
-- and only packages depended by executables, libraries, and test suits will be collected.
getDependencies ::
  (HasCallStack, Members [HackageEnv, FlagAssignmentsEnv, WithMyErr, DependencyRecord, State (Set PackageName), Trace] r) =>
  -- | Skipped
  [UnqualComponentName] ->
  -- | Parent
  Maybe PackageName ->
  -- | Target
  PackageName ->
  Sem r ((G.AdjacencyMap (Set DependencyType) PackageName), Set PackageName)
getDependencies :: [UnqualComponentName]
-> Maybe PackageName
-> PackageName
-> Sem
     r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
getDependencies [UnqualComponentName]
skip Maybe PackageName
parent PackageName
name = do
  Set PackageName
resolved <- forall (r :: [Effect]).
MemberWithError (State (Set PackageName)) r =>
Sem r (Set PackageName)
forall s (r :: [Effect]). MemberWithError (State s) r => Sem r s
get @(Set PackageName)
  (Set PackageName -> Set PackageName) -> Sem r ()
forall s (r :: [Effect]).
Member (State s) r =>
(s -> s) -> Sem r ()
modify' ((Set PackageName -> Set PackageName) -> Sem r ())
-> (Set PackageName -> Set PackageName) -> Sem r ()
forall a b. (a -> b) -> a -> b
$ PackageName -> Set PackageName -> Set PackageName
forall a. Ord a => a -> Set a -> Set a
Set.insert PackageName
name
  String -> Sem r ()
forall (r :: [Effect]).
MemberWithError Trace r =>
String -> Sem r ()
trace' (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ String
"Getting all dependencies of (" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> PackageName -> String
forall a. Show a => a -> String
show PackageName
name String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"), parent: (" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Maybe PackageName -> String
forall a. Show a => a -> String
show Maybe PackageName
parent String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
")"
  String -> Sem r ()
forall (r :: [Effect]).
MemberWithError Trace r =>
String -> Sem r ()
trace' (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ String
"Already resolved: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Set PackageName -> String
forall a. Show a => a -> String
show Set PackageName
resolved
  Sem r ()
forall (r :: [Effect]).
(HasCallStack, MemberWithError Trace r) =>
Sem r ()
traceCallStack
  GenericPackageDescription
cabal <- PackageName -> Sem r GenericPackageDescription
forall (r :: [Effect]).
Members '[HackageEnv, WithMyErr] r =>
PackageName -> Sem r GenericPackageDescription
getLatestCabal PackageName
name
  -- Ignore subLibraries
  (PkgList
libDeps, PkgList
libToolsDeps) <- GenericPackageDescription -> Sem r (PkgList, PkgList)
forall (r :: [Effect]).
Members '[FlagAssignmentsEnv, DependencyRecord, Trace] r =>
GenericPackageDescription -> Sem r (PkgList, PkgList)
collectLibDeps GenericPackageDescription
cabal
  (ComponentPkgList
subLibDeps, ComponentPkgList
subLibToolsDeps) <- GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
forall (r :: [Effect]).
(HasCallStack,
 Members '[FlagAssignmentsEnv, DependencyRecord, Trace] r) =>
GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
collectSubLibDeps GenericPackageDescription
cabal [UnqualComponentName]
skip
  (ComponentPkgList
exeDeps, ComponentPkgList
exeToolsDeps) <- GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
forall (r :: [Effect]).
(HasCallStack,
 Members '[FlagAssignmentsEnv, DependencyRecord, Trace] r) =>
GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
collectExeDeps GenericPackageDescription
cabal [UnqualComponentName]
skip
  (ComponentPkgList
testDeps, ComponentPkgList
testToolsDeps) <- GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
forall (r :: [Effect]).
(HasCallStack,
 Members '[FlagAssignmentsEnv, DependencyRecord, Trace] r) =>
GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
collectTestDeps GenericPackageDescription
cabal [UnqualComponentName]
skip
  -- Ignore benchmarks
  -- (benchDeps, benchToolsDeps) <- collectBenchMarkDeps cabal skip
  let uname :: (UnqualComponentName -> DependencyType) -> ComponentPkgList -> [(DependencyType, PkgList)]
      uname :: (UnqualComponentName -> DependencyType)
-> ComponentPkgList -> [(DependencyType, PkgList)]
uname UnqualComponentName -> DependencyType
cons ComponentPkgList
list = [DependencyType] -> [PkgList] -> [(DependencyType, PkgList)]
forall a b. [a] -> [b] -> [(a, b)]
zip (((UnqualComponentName, PkgList) -> DependencyType)
-> ComponentPkgList -> [DependencyType]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (UnqualComponentName -> DependencyType
cons (UnqualComponentName -> DependencyType)
-> ((UnqualComponentName, PkgList) -> UnqualComponentName)
-> (UnqualComponentName, PkgList)
-> DependencyType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UnqualComponentName, PkgList) -> UnqualComponentName
forall a b. (a, b) -> a
fst) ComponentPkgList
list) (((UnqualComponentName, PkgList) -> PkgList)
-> ComponentPkgList -> [PkgList]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (UnqualComponentName, PkgList) -> PkgList
forall a b. (a, b) -> b
snd ComponentPkgList
list)

      flatten :: [(DependencyType, PkgList)] -> [(DependencyType, PackageName)]
      flatten :: [(DependencyType, PkgList)] -> [(DependencyType, PackageName)]
flatten = [[(DependencyType, PackageName)]]
-> [(DependencyType, PackageName)]
forall a. Monoid a => [a] -> a
mconcat ([[(DependencyType, PackageName)]]
 -> [(DependencyType, PackageName)])
-> ([(DependencyType, PkgList)]
    -> [[(DependencyType, PackageName)]])
-> [(DependencyType, PkgList)]
-> [(DependencyType, PackageName)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((DependencyType, PkgList) -> [(DependencyType, PackageName)])
-> [(DependencyType, PkgList)] -> [[(DependencyType, PackageName)]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(DependencyType
t, PkgList
pkgs) -> [DependencyType] -> PkgList -> [(DependencyType, PackageName)]
forall a b. [a] -> [b] -> [(a, b)]
zip (DependencyType -> [DependencyType]
forall a. a -> [a]
repeat DependencyType
t) PkgList
pkgs)

      withThisName :: [(DependencyType, PackageName)] -> [(DependencyType, PackageName, PackageName)]
      withThisName :: [(DependencyType, PackageName)]
-> [(DependencyType, PackageName, PackageName)]
withThisName = ((DependencyType, PackageName)
 -> (DependencyType, PackageName, PackageName))
-> [(DependencyType, PackageName)]
-> [(DependencyType, PackageName, PackageName)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(DependencyType
t, PackageName
pkg) -> (DependencyType
t, PackageName
name, PackageName
pkg))

      ignoreSingle :: PackageName -> Bool
ignoreSingle PackageName
x = PackageName
x PackageName -> PkgList -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` PkgList
ignoreList
      ignore :: PkgList -> PkgList
ignore = (PackageName -> Bool) -> PkgList -> PkgList
forall a. (a -> Bool) -> [a] -> [a]
filter PackageName -> Bool
ignoreSingle
      ignoreFlatten :: (UnqualComponentName -> DependencyType)
-> ComponentPkgList -> [(DependencyType, PackageName)]
ignoreFlatten UnqualComponentName -> DependencyType
k = ((DependencyType, PackageName) -> Bool)
-> [(DependencyType, PackageName)]
-> [(DependencyType, PackageName)]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(DependencyType
_, PackageName
x) -> PackageName -> Bool
ignoreSingle PackageName
x) ([(DependencyType, PackageName)]
 -> [(DependencyType, PackageName)])
-> (ComponentPkgList -> [(DependencyType, PackageName)])
-> ComponentPkgList
-> [(DependencyType, PackageName)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(DependencyType, PkgList)] -> [(DependencyType, PackageName)]
flatten ([(DependencyType, PkgList)] -> [(DependencyType, PackageName)])
-> (ComponentPkgList -> [(DependencyType, PkgList)])
-> ComponentPkgList
-> [(DependencyType, PackageName)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UnqualComponentName -> DependencyType)
-> ComponentPkgList -> [(DependencyType, PkgList)]
uname UnqualComponentName -> DependencyType
k

      filteredLibDeps :: PkgList
filteredLibDeps = PkgList -> PkgList
ignore PkgList
libDeps
      filteredLibToolsDeps :: PkgList
filteredLibToolsDeps = PkgList -> PkgList
ignore PkgList
libToolsDeps
      filteredExeDeps :: [(DependencyType, PackageName)]
filteredExeDeps = (UnqualComponentName -> DependencyType)
-> ComponentPkgList -> [(DependencyType, PackageName)]
ignoreFlatten UnqualComponentName -> DependencyType
CExe (ComponentPkgList -> [(DependencyType, PackageName)])
-> ComponentPkgList -> [(DependencyType, PackageName)]
forall a b. (a -> b) -> a -> b
$ ComponentPkgList
exeDeps
      filteredExeToolsDeps :: [(DependencyType, PackageName)]
filteredExeToolsDeps = (UnqualComponentName -> DependencyType)
-> ComponentPkgList -> [(DependencyType, PackageName)]
ignoreFlatten UnqualComponentName -> DependencyType
CExeBuildTools (ComponentPkgList -> [(DependencyType, PackageName)])
-> ComponentPkgList -> [(DependencyType, PackageName)]
forall a b. (a -> b) -> a -> b
$ ComponentPkgList
exeToolsDeps
      filteredTestDeps :: [(DependencyType, PackageName)]
filteredTestDeps = (UnqualComponentName -> DependencyType)
-> ComponentPkgList -> [(DependencyType, PackageName)]
ignoreFlatten UnqualComponentName -> DependencyType
CTest (ComponentPkgList -> [(DependencyType, PackageName)])
-> ComponentPkgList -> [(DependencyType, PackageName)]
forall a b. (a -> b) -> a -> b
$ ComponentPkgList
testDeps
      filteredTestToolsDeps :: [(DependencyType, PackageName)]
filteredTestToolsDeps = (UnqualComponentName -> DependencyType)
-> ComponentPkgList -> [(DependencyType, PackageName)]
ignoreFlatten UnqualComponentName -> DependencyType
CTest (ComponentPkgList -> [(DependencyType, PackageName)])
-> ComponentPkgList -> [(DependencyType, PackageName)]
forall a b. (a -> b) -> a -> b
$ ComponentPkgList
testToolsDeps
      filteredSubLibDeps :: [(DependencyType, PackageName)]
filteredSubLibDeps = (UnqualComponentName -> DependencyType)
-> ComponentPkgList -> [(DependencyType, PackageName)]
ignoreFlatten UnqualComponentName -> DependencyType
CSubLibs (ComponentPkgList -> [(DependencyType, PackageName)])
-> ComponentPkgList -> [(DependencyType, PackageName)]
forall a b. (a -> b) -> a -> b
$ ComponentPkgList
subLibDeps
      filteredSubLibToolsDeps :: [(DependencyType, PackageName)]
filteredSubLibToolsDeps = (UnqualComponentName -> DependencyType)
-> ComponentPkgList -> [(DependencyType, PackageName)]
ignoreFlatten UnqualComponentName -> DependencyType
CSubLibsBuildTools (ComponentPkgList -> [(DependencyType, PackageName)])
-> ComponentPkgList -> [(DependencyType, PackageName)]
forall a b. (a -> b) -> a -> b
$ ComponentPkgList
subLibToolsDeps

      filteredSubLibDepsNames :: PkgList
filteredSubLibDepsNames = (UnqualComponentName -> PackageName)
-> [UnqualComponentName] -> PkgList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap UnqualComponentName -> PackageName
unqualComponentNameToPackageName ([UnqualComponentName] -> PkgList)
-> (ComponentPkgList -> [UnqualComponentName])
-> ComponentPkgList
-> PkgList
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((UnqualComponentName, PkgList) -> UnqualComponentName)
-> ComponentPkgList -> [UnqualComponentName]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (UnqualComponentName, PkgList) -> UnqualComponentName
forall a b. (a, b) -> a
fst (ComponentPkgList -> PkgList) -> ComponentPkgList -> PkgList
forall a b. (a -> b) -> a -> b
$ ComponentPkgList
subLibDeps
      ignoreSubLibs :: PkgList -> PkgList
ignoreSubLibs = (PackageName -> Bool) -> PkgList -> PkgList
forall a. (a -> Bool) -> [a] -> [a]
filter (PackageName -> PkgList -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` PkgList
filteredSubLibDepsNames)
      ignoreResolved :: PkgList -> PkgList
ignoreResolved = (PackageName -> Bool) -> PkgList -> PkgList
forall a. (a -> Bool) -> [a] -> [a]
filter (PackageName -> Set PackageName -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` Set PackageName
resolved)

      currentLib :: AdjacencyMap (Set DependencyType) PackageName
currentLib = [(Set DependencyType, PackageName, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
forall e a.
(Eq e, Monoid e, Ord a) =>
[(e, a, a)] -> AdjacencyMap e a
G.edges ([(Set DependencyType, PackageName, PackageName)]
 -> AdjacencyMap (Set DependencyType) PackageName)
-> [(Set DependencyType, PackageName, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
forall a b. (a -> b) -> a -> b
$ [Set DependencyType]
-> PkgList
-> PkgList
-> [(Set DependencyType, PackageName, PackageName)]
forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
zip3 (Set DependencyType -> [Set DependencyType]
forall a. a -> [a]
repeat (Set DependencyType -> [Set DependencyType])
-> Set DependencyType -> [Set DependencyType]
forall a b. (a -> b) -> a -> b
$ DependencyType -> Set DependencyType
forall a. a -> Set a
Set.singleton DependencyType
CLib) (PackageName -> PkgList
forall a. a -> [a]
repeat PackageName
name) PkgList
filteredLibDeps
      currentLibDeps :: AdjacencyMap (Set DependencyType) PackageName
currentLibDeps = [(Set DependencyType, PackageName, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
forall e a.
(Eq e, Monoid e, Ord a) =>
[(e, a, a)] -> AdjacencyMap e a
G.edges ([(Set DependencyType, PackageName, PackageName)]
 -> AdjacencyMap (Set DependencyType) PackageName)
-> [(Set DependencyType, PackageName, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
forall a b. (a -> b) -> a -> b
$ [Set DependencyType]
-> PkgList
-> PkgList
-> [(Set DependencyType, PackageName, PackageName)]
forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
zip3 (Set DependencyType -> [Set DependencyType]
forall a. a -> [a]
repeat (Set DependencyType -> [Set DependencyType])
-> Set DependencyType -> [Set DependencyType]
forall a b. (a -> b) -> a -> b
$ DependencyType -> Set DependencyType
forall a. a -> Set a
Set.singleton DependencyType
CLibBuildTools) (PackageName -> PkgList
forall a. a -> [a]
repeat PackageName
name) PkgList
filteredLibToolsDeps

      componentialEdges :: [(DependencyType, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
componentialEdges =
        [(Set DependencyType, PackageName, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
forall e a.
(Eq e, Monoid e, Ord a) =>
[(e, a, a)] -> AdjacencyMap e a
G.edges
          ([(Set DependencyType, PackageName, PackageName)]
 -> AdjacencyMap (Set DependencyType) PackageName)
-> ([(DependencyType, PackageName)]
    -> [(Set DependencyType, PackageName, PackageName)])
-> [(DependencyType, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((DependencyType, PackageName, PackageName)
 -> (Set DependencyType, PackageName, PackageName))
-> [(DependencyType, PackageName, PackageName)]
-> [(Set DependencyType, PackageName, PackageName)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(DependencyType
x, PackageName
y, PackageName
z) -> (DependencyType -> Set DependencyType
forall a. a -> Set a
Set.singleton DependencyType
x, PackageName
y, PackageName
z))
          ([(DependencyType, PackageName, PackageName)]
 -> [(Set DependencyType, PackageName, PackageName)])
-> ([(DependencyType, PackageName)]
    -> [(DependencyType, PackageName, PackageName)])
-> [(DependencyType, PackageName)]
-> [(Set DependencyType, PackageName, PackageName)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(DependencyType, PackageName)]
-> [(DependencyType, PackageName, PackageName)]
withThisName

      currentSubLibs :: AdjacencyMap (Set DependencyType) PackageName
currentSubLibs = [(DependencyType, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
componentialEdges [(DependencyType, PackageName)]
filteredSubLibDeps
      currentSubLibsTools :: AdjacencyMap (Set DependencyType) PackageName
currentSubLibsTools = [(DependencyType, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
componentialEdges [(DependencyType, PackageName)]
filteredSubLibToolsDeps
      currentExe :: AdjacencyMap (Set DependencyType) PackageName
currentExe = [(DependencyType, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
componentialEdges [(DependencyType, PackageName)]
filteredExeDeps
      currentExeTools :: AdjacencyMap (Set DependencyType) PackageName
currentExeTools = [(DependencyType, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
componentialEdges [(DependencyType, PackageName)]
filteredExeToolsDeps
      currentTest :: AdjacencyMap (Set DependencyType) PackageName
currentTest = [(DependencyType, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
componentialEdges [(DependencyType, PackageName)]
filteredTestDeps
      currentTestTools :: AdjacencyMap (Set DependencyType) PackageName
currentTestTools = [(DependencyType, PackageName)]
-> AdjacencyMap (Set DependencyType) PackageName
componentialEdges [(DependencyType, PackageName)]
filteredTestToolsDeps

      -- currentBench = componentialEdges Types.Benchmark benchDeps
      -- currentBenchTools = componentialEdges BenchmarkBuildTools benchToolsDeps

      <+> :: AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
(<+>) = AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
forall e a.
(Eq e, Monoid e, Ord a) =>
AdjacencyMap e a -> AdjacencyMap e a -> AdjacencyMap e a
G.overlay
  -- Only solve lib & exe deps recursively.
  [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
nextLib <- (PackageName
 -> Sem
      r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName))
-> PkgList
-> Sem
     r
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ([UnqualComponentName]
-> Maybe PackageName
-> PackageName
-> Sem
     r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
forall (r :: [Effect]).
(HasCallStack,
 Members
   '[HackageEnv, FlagAssignmentsEnv, WithMyErr, DependencyRecord,
     State (Set PackageName), Trace]
   r) =>
[UnqualComponentName]
-> Maybe PackageName
-> PackageName
-> Sem
     r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
getDependencies [UnqualComponentName]
skip (PackageName -> Maybe PackageName
forall a. a -> Maybe a
Just PackageName
name)) (PkgList
 -> Sem
      r
      [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)])
-> (PkgList -> PkgList)
-> PkgList
-> Sem
     r
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PkgList -> PkgList
ignoreResolved (PkgList -> PkgList) -> (PkgList -> PkgList) -> PkgList -> PkgList
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PkgList -> PkgList
ignoreSubLibs (PkgList
 -> Sem
      r
      [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)])
-> PkgList
-> Sem
     r
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
forall a b. (a -> b) -> a -> b
$ PkgList
filteredLibDeps
  [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
nextExe <- (PackageName
 -> Sem
      r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName))
-> PkgList
-> Sem
     r
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ([UnqualComponentName]
-> Maybe PackageName
-> PackageName
-> Sem
     r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
forall (r :: [Effect]).
(HasCallStack,
 Members
   '[HackageEnv, FlagAssignmentsEnv, WithMyErr, DependencyRecord,
     State (Set PackageName), Trace]
   r) =>
[UnqualComponentName]
-> Maybe PackageName
-> PackageName
-> Sem
     r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
getDependencies [UnqualComponentName]
skip (PackageName -> Maybe PackageName
forall a. a -> Maybe a
Just PackageName
name)) (PkgList
 -> Sem
      r
      [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)])
-> (PkgList -> PkgList)
-> PkgList
-> Sem
     r
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PkgList -> PkgList
ignoreResolved (PkgList -> PkgList) -> (PkgList -> PkgList) -> PkgList -> PkgList
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PkgList -> PkgList
ignoreSubLibs (PkgList
 -> Sem
      r
      [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)])
-> PkgList
-> Sem
     r
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
forall a b. (a -> b) -> a -> b
$ ((DependencyType, PackageName) -> PackageName)
-> [(DependencyType, PackageName)] -> PkgList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (DependencyType, PackageName) -> PackageName
forall a b. (a, b) -> b
snd [(DependencyType, PackageName)]
filteredExeDeps
  [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
nextSubLibs <- (PackageName
 -> Sem
      r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName))
-> PkgList
-> Sem
     r
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ([UnqualComponentName]
-> Maybe PackageName
-> PackageName
-> Sem
     r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
forall (r :: [Effect]).
(HasCallStack,
 Members
   '[HackageEnv, FlagAssignmentsEnv, WithMyErr, DependencyRecord,
     State (Set PackageName), Trace]
   r) =>
[UnqualComponentName]
-> Maybe PackageName
-> PackageName
-> Sem
     r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
getDependencies [UnqualComponentName]
skip (PackageName -> Maybe PackageName
forall a. a -> Maybe a
Just PackageName
name)) (PkgList
 -> Sem
      r
      [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)])
-> PkgList
-> Sem
     r
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
forall a b. (a -> b) -> a -> b
$ ((DependencyType, PackageName) -> PackageName)
-> [(DependencyType, PackageName)] -> PkgList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (DependencyType, PackageName) -> PackageName
forall a b. (a, b) -> b
snd [(DependencyType, PackageName)]
filteredSubLibDeps
  let temp :: [[(AdjacencyMap (Set DependencyType) PackageName,
   Set PackageName)]]
temp = [[(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
nextLib, [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
nextExe, [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
nextSubLibs]
      nexts :: AdjacencyMap (Set DependencyType) PackageName
nexts = [AdjacencyMap (Set DependencyType) PackageName]
-> AdjacencyMap (Set DependencyType) PackageName
forall e a.
(Eq e, Monoid e, Ord a) =>
[AdjacencyMap e a] -> AdjacencyMap e a
G.overlays ([AdjacencyMap (Set DependencyType) PackageName]
 -> AdjacencyMap (Set DependencyType) PackageName)
-> [AdjacencyMap (Set DependencyType) PackageName]
-> AdjacencyMap (Set DependencyType) PackageName
forall a b. (a -> b) -> a -> b
$ [[(AdjacencyMap (Set DependencyType) PackageName,
   Set PackageName)]]
temp [[(AdjacencyMap (Set DependencyType) PackageName,
   Set PackageName)]]
-> Getting
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
     [[(AdjacencyMap (Set DependencyType) PackageName,
        Set PackageName)]]
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
-> [(AdjacencyMap (Set DependencyType) PackageName,
     Set PackageName)]
forall s a. s -> Getting a s a -> a
^. Getting
  [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
  [[(AdjacencyMap (Set DependencyType) PackageName,
     Set PackageName)]]
  [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
forall s t a b. Each s t a b => Traversal s t a b
each [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
-> Getting
     (Endo [AdjacencyMap (Set DependencyType) PackageName])
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
     (AdjacencyMap (Set DependencyType) PackageName)
-> [AdjacencyMap (Set DependencyType) PackageName]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. ((AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
 -> Const
      (Endo [AdjacencyMap (Set DependencyType) PackageName])
      (AdjacencyMap (Set DependencyType) PackageName, Set PackageName))
-> [(AdjacencyMap (Set DependencyType) PackageName,
     Set PackageName)]
-> Const
     (Endo [AdjacencyMap (Set DependencyType) PackageName])
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
forall s t a b. Each s t a b => Traversal s t a b
each (((AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
  -> Const
       (Endo [AdjacencyMap (Set DependencyType) PackageName])
       (AdjacencyMap (Set DependencyType) PackageName, Set PackageName))
 -> [(AdjacencyMap (Set DependencyType) PackageName,
      Set PackageName)]
 -> Const
      (Endo [AdjacencyMap (Set DependencyType) PackageName])
      [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)])
-> ((AdjacencyMap (Set DependencyType) PackageName
     -> Const
          (Endo [AdjacencyMap (Set DependencyType) PackageName])
          (AdjacencyMap (Set DependencyType) PackageName))
    -> (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
    -> Const
         (Endo [AdjacencyMap (Set DependencyType) PackageName])
         (AdjacencyMap (Set DependencyType) PackageName, Set PackageName))
-> Getting
     (Endo [AdjacencyMap (Set DependencyType) PackageName])
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
     (AdjacencyMap (Set DependencyType) PackageName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AdjacencyMap (Set DependencyType) PackageName
 -> Const
      (Endo [AdjacencyMap (Set DependencyType) PackageName])
      (AdjacencyMap (Set DependencyType) PackageName))
-> (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
-> Const
     (Endo [AdjacencyMap (Set DependencyType) PackageName])
     (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
forall s t a b. Field1 s t a b => Lens s t a b
_1
      subsubs :: Set PackageName
subsubs = [[(AdjacencyMap (Set DependencyType) PackageName,
   Set PackageName)]]
temp [[(AdjacencyMap (Set DependencyType) PackageName,
   Set PackageName)]]
-> Getting
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
     [[(AdjacencyMap (Set DependencyType) PackageName,
        Set PackageName)]]
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
-> [(AdjacencyMap (Set DependencyType) PackageName,
     Set PackageName)]
forall s a. s -> Getting a s a -> a
^. Getting
  [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
  [[(AdjacencyMap (Set DependencyType) PackageName,
     Set PackageName)]]
  [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
forall s t a b. Each s t a b => Traversal s t a b
each [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
-> Getting
     (Endo [Set PackageName])
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
     (Set PackageName)
-> [Set PackageName]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. ((AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
 -> Const
      (Endo [Set PackageName])
      (AdjacencyMap (Set DependencyType) PackageName, Set PackageName))
-> [(AdjacencyMap (Set DependencyType) PackageName,
     Set PackageName)]
-> Const
     (Endo [Set PackageName])
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
forall s t a b. Each s t a b => Traversal s t a b
each (((AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
  -> Const
       (Endo [Set PackageName])
       (AdjacencyMap (Set DependencyType) PackageName, Set PackageName))
 -> [(AdjacencyMap (Set DependencyType) PackageName,
      Set PackageName)]
 -> Const
      (Endo [Set PackageName])
      [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)])
-> ((Set PackageName
     -> Const (Endo [Set PackageName]) (Set PackageName))
    -> (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
    -> Const
         (Endo [Set PackageName])
         (AdjacencyMap (Set DependencyType) PackageName, Set PackageName))
-> Getting
     (Endo [Set PackageName])
     [(AdjacencyMap (Set DependencyType) PackageName, Set PackageName)]
     (Set PackageName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set PackageName
 -> Const (Endo [Set PackageName]) (Set PackageName))
-> (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
-> Const
     (Endo [Set PackageName])
     (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
forall s t a b. Field2 s t a b => Lens s t a b
_2 [Set PackageName]
-> Getting (Set PackageName) [Set PackageName] (Set PackageName)
-> Set PackageName
forall s a. s -> Getting a s a -> a
^. Getting (Set PackageName) [Set PackageName] (Set PackageName)
forall s t a b. Each s t a b => Traversal s t a b
each
  (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
-> Sem
     r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
forall (m :: * -> *) a. Monad m => a -> m a
return ((AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
 -> Sem
      r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName))
-> (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
-> Sem
     r (AdjacencyMap (Set DependencyType) PackageName, Set PackageName)
forall a b. (a -> b) -> a -> b
$
    ( AdjacencyMap (Set DependencyType) PackageName
currentLib
        AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
<+> AdjacencyMap (Set DependencyType) PackageName
currentLibDeps
        AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
<+> AdjacencyMap (Set DependencyType) PackageName
currentExe
        AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
<+> AdjacencyMap (Set DependencyType) PackageName
currentExeTools
        AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
<+> AdjacencyMap (Set DependencyType) PackageName
currentTest
        AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
<+> AdjacencyMap (Set DependencyType) PackageName
currentTestTools
        AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
<+> AdjacencyMap (Set DependencyType) PackageName
currentSubLibs
        AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
<+> AdjacencyMap (Set DependencyType) PackageName
currentSubLibsTools
        -- <+> currentBench
        -- <+> currentBenchTools
        AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
-> AdjacencyMap (Set DependencyType) PackageName
<+> AdjacencyMap (Set DependencyType) PackageName
nexts,
      PkgList -> Set PackageName
forall a. Ord a => [a] -> Set a
Set.fromList PkgList
filteredSubLibDepsNames Set PackageName -> Set PackageName -> Set PackageName
forall a. Semigroup a => a -> a -> a
<> Set PackageName
subsubs
    )

collectLibDeps :: Members [FlagAssignmentsEnv, DependencyRecord, Trace] r => GenericPackageDescription -> Sem r (PkgList, PkgList)
collectLibDeps :: GenericPackageDescription -> Sem r (PkgList, PkgList)
collectLibDeps GenericPackageDescription
cabal = do
  case GenericPackageDescription
cabal GenericPackageDescription
-> (GenericPackageDescription
    -> Maybe (CondTree ConfVar [Dependency] Library))
-> Maybe (CondTree ConfVar [Dependency] Library)
forall a b. a -> (a -> b) -> b
& GenericPackageDescription
-> Maybe (CondTree ConfVar [Dependency] Library)
condLibrary of
    Just CondTree ConfVar [Dependency] Library
lib -> do
      let name :: PackageName
name = GenericPackageDescription -> PackageName
getPkgName' GenericPackageDescription
cabal
      String -> Sem r ()
forall (r :: [Effect]).
MemberWithError Trace r =>
String -> Sem r ()
trace' (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ String
"Getting componential dependencies of " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> PackageName -> String
forall a. Show a => a -> String
show PackageName
name
      BuildInfo
info <- GenericPackageDescription
-> CondTree ConfVar [Dependency] Library -> Sem r BuildInfo
forall k (r :: [Effect]).
(HasCallStack, Semigroup k, HasBuildInfo k,
 Members '[FlagAssignmentsEnv, Trace] r) =>
GenericPackageDescription
-> CondTree ConfVar [Dependency] k -> Sem r BuildInfo
evalConditionTree GenericPackageDescription
cabal CondTree ConfVar [Dependency] Library
lib
      let libDeps :: [(PackageName, VersionRange)]
libDeps = (Dependency -> (PackageName, VersionRange))
-> [Dependency] -> [(PackageName, VersionRange)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Dependency -> (PackageName, VersionRange)
unDepV ([Dependency] -> [(PackageName, VersionRange)])
-> [Dependency] -> [(PackageName, VersionRange)]
forall a b. (a -> b) -> a -> b
$ BuildInfo -> [Dependency]
buildDependsIfBuild BuildInfo
info
          toolDeps :: [(PackageName, VersionRange)]
toolDeps = (ExeDependency -> (PackageName, VersionRange))
-> [ExeDependency] -> [(PackageName, VersionRange)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ExeDependency -> (PackageName, VersionRange)
unExeV ([ExeDependency] -> [(PackageName, VersionRange)])
-> [ExeDependency] -> [(PackageName, VersionRange)]
forall a b. (a -> b) -> a -> b
$ BuildInfo -> [ExeDependency]
buildToolDependsIfBuild BuildInfo
info
      ((PackageName, VersionRange) -> Sem r ())
-> [(PackageName, VersionRange)] -> Sem r ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ((PackageName -> VersionRange -> Sem r ())
-> (PackageName, VersionRange) -> Sem r ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry PackageName -> VersionRange -> Sem r ()
forall (r :: [Effect]).
Member DependencyRecord r =>
PackageName -> VersionRange -> Sem r ()
updateDependencyRecord) [(PackageName, VersionRange)]
libDeps
      ((PackageName, VersionRange) -> Sem r ())
-> [(PackageName, VersionRange)] -> Sem r ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ((PackageName -> VersionRange -> Sem r ())
-> (PackageName, VersionRange) -> Sem r ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry PackageName -> VersionRange -> Sem r ()
forall (r :: [Effect]).
Member DependencyRecord r =>
PackageName -> VersionRange -> Sem r ()
updateDependencyRecord) [(PackageName, VersionRange)]
toolDeps
      let result :: (PkgList, PkgList)
result = (((PackageName, VersionRange) -> PackageName)
-> [(PackageName, VersionRange)] -> PkgList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (PackageName, VersionRange) -> PackageName
forall a b. (a, b) -> a
fst [(PackageName, VersionRange)]
libDeps, ((PackageName, VersionRange) -> PackageName)
-> [(PackageName, VersionRange)] -> PkgList
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (PackageName, VersionRange) -> PackageName
forall a b. (a, b) -> a
fst [(PackageName, VersionRange)]
toolDeps)
      String -> Sem r ()
forall (r :: [Effect]).
MemberWithError Trace r =>
String -> Sem r ()
trace' (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ String
"Found: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> (PkgList, PkgList) -> String
forall a. Show a => a -> String
show (PkgList, PkgList)
result
      Sem r ()
forall (r :: [Effect]).
(HasCallStack, MemberWithError Trace r) =>
Sem r ()
traceCallStack
      (PkgList, PkgList) -> Sem r (PkgList, PkgList)
forall (m :: * -> *) a. Monad m => a -> m a
return (PkgList, PkgList)
result
    Maybe (CondTree ConfVar [Dependency] Library)
Nothing -> (PkgList, PkgList) -> Sem r (PkgList, PkgList)
forall (m :: * -> *) a. Monad m => a -> m a
return ([], [])

collectComponentialDeps ::
  (HasCallStack, Semigroup k, L.HasBuildInfo k, Members [FlagAssignmentsEnv, DependencyRecord, Trace] r) =>
  (GenericPackageDescription -> [(UnqualComponentName, CondTree ConfVar [Dependency] k)]) ->
  GenericPackageDescription ->
  [UnqualComponentName] ->
  Sem r (ComponentPkgList, ComponentPkgList)
collectComponentialDeps :: (GenericPackageDescription
 -> [(UnqualComponentName, CondTree ConfVar [Dependency] k)])
-> GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
collectComponentialDeps GenericPackageDescription
-> [(UnqualComponentName, CondTree ConfVar [Dependency] k)]
f GenericPackageDescription
cabal [UnqualComponentName]
skip = do
  let conds :: [(UnqualComponentName, CondTree ConfVar [Dependency] k)]
conds = GenericPackageDescription
cabal GenericPackageDescription
-> (GenericPackageDescription
    -> [(UnqualComponentName, CondTree ConfVar [Dependency] k)])
-> [(UnqualComponentName, CondTree ConfVar [Dependency] k)]
forall a b. a -> (a -> b) -> b
& GenericPackageDescription
-> [(UnqualComponentName, CondTree ConfVar [Dependency] k)]
f
      name :: PackageName
name = GenericPackageDescription -> PackageName
getPkgName' GenericPackageDescription
cabal
  String -> Sem r ()
forall (r :: [Effect]).
MemberWithError Trace r =>
String -> Sem r ()
trace' (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ String
"Getting componential dependencies of " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> PackageName -> String
forall a. Show a => a -> String
show PackageName
name
  [(UnqualComponentName, BuildInfo)]
info <- ((UnqualComponentName, BuildInfo) -> Bool)
-> [(UnqualComponentName, BuildInfo)]
-> [(UnqualComponentName, BuildInfo)]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool)
-> ((UnqualComponentName, BuildInfo) -> Bool)
-> (UnqualComponentName, BuildInfo)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UnqualComponentName -> [UnqualComponentName] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [UnqualComponentName]
skip) (UnqualComponentName -> Bool)
-> ((UnqualComponentName, BuildInfo) -> UnqualComponentName)
-> (UnqualComponentName, BuildInfo)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UnqualComponentName, BuildInfo) -> UnqualComponentName
forall a b. (a, b) -> a
fst) ([(UnqualComponentName, BuildInfo)]
 -> [(UnqualComponentName, BuildInfo)])
-> ([BuildInfo] -> [(UnqualComponentName, BuildInfo)])
-> [BuildInfo]
-> [(UnqualComponentName, BuildInfo)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [UnqualComponentName]
-> [BuildInfo] -> [(UnqualComponentName, BuildInfo)]
forall a b. [a] -> [b] -> [(a, b)]
zip ([(UnqualComponentName, CondTree ConfVar [Dependency] k)]
conds [(UnqualComponentName, CondTree ConfVar [Dependency] k)]
-> ((UnqualComponentName, CondTree ConfVar [Dependency] k)
    -> UnqualComponentName)
-> [UnqualComponentName]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (UnqualComponentName, CondTree ConfVar [Dependency] k)
-> UnqualComponentName
forall a b. (a, b) -> a
fst) ([BuildInfo] -> [(UnqualComponentName, BuildInfo)])
-> Sem r [BuildInfo] -> Sem r [(UnqualComponentName, BuildInfo)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((UnqualComponentName, CondTree ConfVar [Dependency] k)
 -> Sem r BuildInfo)
-> [(UnqualComponentName, CondTree ConfVar [Dependency] k)]
-> Sem r [BuildInfo]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (GenericPackageDescription
-> CondTree ConfVar [Dependency] k -> Sem r BuildInfo
forall k (r :: [Effect]).
(HasCallStack, Semigroup k, HasBuildInfo k,
 Members '[FlagAssignmentsEnv, Trace] r) =>
GenericPackageDescription
-> CondTree ConfVar [Dependency] k -> Sem r BuildInfo
evalConditionTree GenericPackageDescription
cabal (CondTree ConfVar [Dependency] k -> Sem r BuildInfo)
-> ((UnqualComponentName, CondTree ConfVar [Dependency] k)
    -> CondTree ConfVar [Dependency] k)
-> (UnqualComponentName, CondTree ConfVar [Dependency] k)
-> Sem r BuildInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (UnqualComponentName, CondTree ConfVar [Dependency] k)
-> CondTree ConfVar [Dependency] k
forall a b. (a, b) -> b
snd) [(UnqualComponentName, CondTree ConfVar [Dependency] k)]
conds
  let deps :: [(UnqualComponentName, [(PackageName, VersionRange)])]
deps = [(UnqualComponentName, BuildInfo)]
info [(UnqualComponentName, BuildInfo)]
-> ((UnqualComponentName, BuildInfo)
    -> (UnqualComponentName, [(PackageName, VersionRange)]))
-> [(UnqualComponentName, [(PackageName, VersionRange)])]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (((BuildInfo -> Identity [(PackageName, VersionRange)])
-> (UnqualComponentName, BuildInfo)
-> Identity (UnqualComponentName, [(PackageName, VersionRange)])
forall s t a b. Field2 s t a b => Lens s t a b
_2 ((BuildInfo -> Identity [(PackageName, VersionRange)])
 -> (UnqualComponentName, BuildInfo)
 -> Identity (UnqualComponentName, [(PackageName, VersionRange)]))
-> (BuildInfo -> [(PackageName, VersionRange)])
-> (UnqualComponentName, BuildInfo)
-> (UnqualComponentName, [(PackageName, VersionRange)])
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~) ((BuildInfo -> [(PackageName, VersionRange)])
 -> (UnqualComponentName, BuildInfo)
 -> (UnqualComponentName, [(PackageName, VersionRange)]))
-> (BuildInfo -> [(PackageName, VersionRange)])
-> (UnqualComponentName, BuildInfo)
-> (UnqualComponentName, [(PackageName, VersionRange)])
forall a b. (a -> b) -> a -> b
$ (Dependency -> (PackageName, VersionRange))
-> [Dependency] -> [(PackageName, VersionRange)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Dependency -> (PackageName, VersionRange)
unDepV ([Dependency] -> [(PackageName, VersionRange)])
-> (BuildInfo -> [Dependency])
-> BuildInfo
-> [(PackageName, VersionRange)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BuildInfo -> [Dependency]
buildDependsIfBuild)
      toolDeps :: [(UnqualComponentName, [(PackageName, VersionRange)])]
toolDeps = [(UnqualComponentName, BuildInfo)]
info [(UnqualComponentName, BuildInfo)]
-> ((UnqualComponentName, BuildInfo)
    -> (UnqualComponentName, [(PackageName, VersionRange)]))
-> [(UnqualComponentName, [(PackageName, VersionRange)])]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (((BuildInfo -> Identity [(PackageName, VersionRange)])
-> (UnqualComponentName, BuildInfo)
-> Identity (UnqualComponentName, [(PackageName, VersionRange)])
forall s t a b. Field2 s t a b => Lens s t a b
_2 ((BuildInfo -> Identity [(PackageName, VersionRange)])
 -> (UnqualComponentName, BuildInfo)
 -> Identity (UnqualComponentName, [(PackageName, VersionRange)]))
-> (BuildInfo -> [(PackageName, VersionRange)])
-> (UnqualComponentName, BuildInfo)
-> (UnqualComponentName, [(PackageName, VersionRange)])
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~) ((BuildInfo -> [(PackageName, VersionRange)])
 -> (UnqualComponentName, BuildInfo)
 -> (UnqualComponentName, [(PackageName, VersionRange)]))
-> (BuildInfo -> [(PackageName, VersionRange)])
-> (UnqualComponentName, BuildInfo)
-> (UnqualComponentName, [(PackageName, VersionRange)])
forall a b. (a -> b) -> a -> b
$ (ExeDependency -> (PackageName, VersionRange))
-> [ExeDependency] -> [(PackageName, VersionRange)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ExeDependency -> (PackageName, VersionRange)
unExeV ([ExeDependency] -> [(PackageName, VersionRange)])
-> (BuildInfo -> [ExeDependency])
-> BuildInfo
-> [(PackageName, VersionRange)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BuildInfo -> [ExeDependency]
buildToolDependsIfBuild)
      k :: [(a, [(b, b)])] -> [(a, [b])]
k = ((a, [(b, b)]) -> (a, [b])) -> [(a, [(b, b)])] -> [(a, [b])]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(a
c, [(b, b)]
l) -> (a
c, ((b, b) -> b) -> [(b, b)] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (b, b) -> b
forall a b. (a, b) -> a
fst [(b, b)]
l))
  ((PackageName, VersionRange) -> Sem r ())
-> [(PackageName, VersionRange)] -> Sem r ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ((PackageName -> VersionRange -> Sem r ())
-> (PackageName, VersionRange) -> Sem r ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry PackageName -> VersionRange -> Sem r ()
forall (r :: [Effect]).
Member DependencyRecord r =>
PackageName -> VersionRange -> Sem r ()
updateDependencyRecord) ([(PackageName, VersionRange)] -> Sem r ())
-> [(PackageName, VersionRange)] -> Sem r ()
forall a b. (a -> b) -> a -> b
$ [(UnqualComponentName, [(PackageName, VersionRange)])]
deps [(UnqualComponentName, [(PackageName, VersionRange)])]
-> Getting
     (Endo [[(PackageName, VersionRange)]])
     [(UnqualComponentName, [(PackageName, VersionRange)])]
     [(PackageName, VersionRange)]
-> [[(PackageName, VersionRange)]]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. ((UnqualComponentName, [(PackageName, VersionRange)])
 -> Const
      (Endo [[(PackageName, VersionRange)]])
      (UnqualComponentName, [(PackageName, VersionRange)]))
-> [(UnqualComponentName, [(PackageName, VersionRange)])]
-> Const
     (Endo [[(PackageName, VersionRange)]])
     [(UnqualComponentName, [(PackageName, VersionRange)])]
forall s t a b. Each s t a b => Traversal s t a b
each (((UnqualComponentName, [(PackageName, VersionRange)])
  -> Const
       (Endo [[(PackageName, VersionRange)]])
       (UnqualComponentName, [(PackageName, VersionRange)]))
 -> [(UnqualComponentName, [(PackageName, VersionRange)])]
 -> Const
      (Endo [[(PackageName, VersionRange)]])
      [(UnqualComponentName, [(PackageName, VersionRange)])])
-> (([(PackageName, VersionRange)]
     -> Const
          (Endo [[(PackageName, VersionRange)]])
          [(PackageName, VersionRange)])
    -> (UnqualComponentName, [(PackageName, VersionRange)])
    -> Const
         (Endo [[(PackageName, VersionRange)]])
         (UnqualComponentName, [(PackageName, VersionRange)]))
-> Getting
     (Endo [[(PackageName, VersionRange)]])
     [(UnqualComponentName, [(PackageName, VersionRange)])]
     [(PackageName, VersionRange)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([(PackageName, VersionRange)]
 -> Const
      (Endo [[(PackageName, VersionRange)]])
      [(PackageName, VersionRange)])
-> (UnqualComponentName, [(PackageName, VersionRange)])
-> Const
     (Endo [[(PackageName, VersionRange)]])
     (UnqualComponentName, [(PackageName, VersionRange)])
forall s t a b. Field2 s t a b => Lens s t a b
_2 [[(PackageName, VersionRange)]]
-> Getting
     [(PackageName, VersionRange)]
     [[(PackageName, VersionRange)]]
     [(PackageName, VersionRange)]
-> [(PackageName, VersionRange)]
forall s a. s -> Getting a s a -> a
^. Getting
  [(PackageName, VersionRange)]
  [[(PackageName, VersionRange)]]
  [(PackageName, VersionRange)]
forall s t a b. Each s t a b => Traversal s t a b
each
  ((PackageName, VersionRange) -> Sem r ())
-> [(PackageName, VersionRange)] -> Sem r ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ ((PackageName -> VersionRange -> Sem r ())
-> (PackageName, VersionRange) -> Sem r ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry PackageName -> VersionRange -> Sem r ()
forall (r :: [Effect]).
Member DependencyRecord r =>
PackageName -> VersionRange -> Sem r ()
updateDependencyRecord) ([(PackageName, VersionRange)] -> Sem r ())
-> [(PackageName, VersionRange)] -> Sem r ()
forall a b. (a -> b) -> a -> b
$ [(UnqualComponentName, [(PackageName, VersionRange)])]
toolDeps [(UnqualComponentName, [(PackageName, VersionRange)])]
-> Getting
     (Endo [[(PackageName, VersionRange)]])
     [(UnqualComponentName, [(PackageName, VersionRange)])]
     [(PackageName, VersionRange)]
-> [[(PackageName, VersionRange)]]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. ((UnqualComponentName, [(PackageName, VersionRange)])
 -> Const
      (Endo [[(PackageName, VersionRange)]])
      (UnqualComponentName, [(PackageName, VersionRange)]))
-> [(UnqualComponentName, [(PackageName, VersionRange)])]
-> Const
     (Endo [[(PackageName, VersionRange)]])
     [(UnqualComponentName, [(PackageName, VersionRange)])]
forall s t a b. Each s t a b => Traversal s t a b
each (((UnqualComponentName, [(PackageName, VersionRange)])
  -> Const
       (Endo [[(PackageName, VersionRange)]])
       (UnqualComponentName, [(PackageName, VersionRange)]))
 -> [(UnqualComponentName, [(PackageName, VersionRange)])]
 -> Const
      (Endo [[(PackageName, VersionRange)]])
      [(UnqualComponentName, [(PackageName, VersionRange)])])
-> (([(PackageName, VersionRange)]
     -> Const
          (Endo [[(PackageName, VersionRange)]])
          [(PackageName, VersionRange)])
    -> (UnqualComponentName, [(PackageName, VersionRange)])
    -> Const
         (Endo [[(PackageName, VersionRange)]])
         (UnqualComponentName, [(PackageName, VersionRange)]))
-> Getting
     (Endo [[(PackageName, VersionRange)]])
     [(UnqualComponentName, [(PackageName, VersionRange)])]
     [(PackageName, VersionRange)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([(PackageName, VersionRange)]
 -> Const
      (Endo [[(PackageName, VersionRange)]])
      [(PackageName, VersionRange)])
-> (UnqualComponentName, [(PackageName, VersionRange)])
-> Const
     (Endo [[(PackageName, VersionRange)]])
     (UnqualComponentName, [(PackageName, VersionRange)])
forall s t a b. Field2 s t a b => Lens s t a b
_2 [[(PackageName, VersionRange)]]
-> Getting
     [(PackageName, VersionRange)]
     [[(PackageName, VersionRange)]]
     [(PackageName, VersionRange)]
-> [(PackageName, VersionRange)]
forall s a. s -> Getting a s a -> a
^. Getting
  [(PackageName, VersionRange)]
  [[(PackageName, VersionRange)]]
  [(PackageName, VersionRange)]
forall s t a b. Each s t a b => Traversal s t a b
each
  let result :: (ComponentPkgList, ComponentPkgList)
result = ([(UnqualComponentName, [(PackageName, VersionRange)])]
-> ComponentPkgList
forall a b b. [(a, [(b, b)])] -> [(a, [b])]
k [(UnqualComponentName, [(PackageName, VersionRange)])]
deps, [(UnqualComponentName, [(PackageName, VersionRange)])]
-> ComponentPkgList
forall a b b. [(a, [(b, b)])] -> [(a, [b])]
k [(UnqualComponentName, [(PackageName, VersionRange)])]
toolDeps)
  String -> Sem r ()
forall (r :: [Effect]).
MemberWithError Trace r =>
String -> Sem r ()
trace' (String -> Sem r ()) -> String -> Sem r ()
forall a b. (a -> b) -> a -> b
$ String
"Found: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> (ComponentPkgList, ComponentPkgList) -> String
forall a. Show a => a -> String
show (ComponentPkgList, ComponentPkgList)
result
  Sem r ()
forall (r :: [Effect]).
(HasCallStack, MemberWithError Trace r) =>
Sem r ()
traceCallStack
  (ComponentPkgList, ComponentPkgList)
-> Sem r (ComponentPkgList, ComponentPkgList)
forall (m :: * -> *) a. Monad m => a -> m a
return (ComponentPkgList, ComponentPkgList)
result

collectExeDeps :: (HasCallStack, Members [FlagAssignmentsEnv, DependencyRecord, Trace] r) => GenericPackageDescription -> [UnqualComponentName] -> Sem r (ComponentPkgList, ComponentPkgList)
collectExeDeps :: GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
collectExeDeps = (GenericPackageDescription
 -> [(UnqualComponentName,
      CondTree ConfVar [Dependency] Executable)])
-> GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
forall k (r :: [Effect]).
(HasCallStack, Semigroup k, HasBuildInfo k,
 Members '[FlagAssignmentsEnv, DependencyRecord, Trace] r) =>
(GenericPackageDescription
 -> [(UnqualComponentName, CondTree ConfVar [Dependency] k)])
-> GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
collectComponentialDeps GenericPackageDescription
-> [(UnqualComponentName,
     CondTree ConfVar [Dependency] Executable)]
condExecutables

collectTestDeps :: (HasCallStack, Members [FlagAssignmentsEnv, DependencyRecord, Trace] r) => GenericPackageDescription -> [UnqualComponentName] -> Sem r (ComponentPkgList, ComponentPkgList)
collectTestDeps :: GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
collectTestDeps = (GenericPackageDescription
 -> [(UnqualComponentName,
      CondTree ConfVar [Dependency] TestSuite)])
-> GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
forall k (r :: [Effect]).
(HasCallStack, Semigroup k, HasBuildInfo k,
 Members '[FlagAssignmentsEnv, DependencyRecord, Trace] r) =>
(GenericPackageDescription
 -> [(UnqualComponentName, CondTree ConfVar [Dependency] k)])
-> GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
collectComponentialDeps GenericPackageDescription
-> [(UnqualComponentName, CondTree ConfVar [Dependency] TestSuite)]
condTestSuites

collectSubLibDeps :: (HasCallStack, Members [FlagAssignmentsEnv, DependencyRecord, Trace] r) => GenericPackageDescription -> [UnqualComponentName] -> Sem r (ComponentPkgList, ComponentPkgList)
collectSubLibDeps :: GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
collectSubLibDeps = (GenericPackageDescription
 -> [(UnqualComponentName, CondTree ConfVar [Dependency] Library)])
-> GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
forall k (r :: [Effect]).
(HasCallStack, Semigroup k, HasBuildInfo k,
 Members '[FlagAssignmentsEnv, DependencyRecord, Trace] r) =>
(GenericPackageDescription
 -> [(UnqualComponentName, CondTree ConfVar [Dependency] k)])
-> GenericPackageDescription
-> [UnqualComponentName]
-> Sem r (ComponentPkgList, ComponentPkgList)
collectComponentialDeps GenericPackageDescription
-> [(UnqualComponentName, CondTree ConfVar [Dependency] Library)]
condSubLibraries

updateDependencyRecord :: Member DependencyRecord r => PackageName -> VersionRange -> Sem r ()
updateDependencyRecord :: PackageName -> VersionRange -> Sem r ()
updateDependencyRecord PackageName
name VersionRange
range = (Map PackageName [VersionRange] -> Map PackageName [VersionRange])
-> Sem r ()
forall s (r :: [Effect]).
Member (State s) r =>
(s -> s) -> Sem r ()
modify' ((Map PackageName [VersionRange] -> Map PackageName [VersionRange])
 -> Sem r ())
-> (Map PackageName [VersionRange]
    -> Map PackageName [VersionRange])
-> Sem r ()
forall a b. (a -> b) -> a -> b
$ ([VersionRange] -> [VersionRange] -> [VersionRange])
-> PackageName
-> [VersionRange]
-> Map PackageName [VersionRange]
-> Map PackageName [VersionRange]
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith [VersionRange] -> [VersionRange] -> [VersionRange]
forall a. Semigroup a => a -> a -> a
(<>) PackageName
name [VersionRange
range]

-- collectBenchMarkDeps :: Members [HackageEnv, FlagAssignmentEnv] r => GenericPackageDescription -> [UnqualComponentName] -> Sem r (ComponentPkgList, ComponentPkgList)
-- collectBenchMarkDeps = collectComponentialDeps condBenchmarks

-----------------------------------------------------------------------------

-- | Generate 'PkgBuild' for a 'SolvedPackage'.
cabalToPkgBuild :: Members [HackageEnv, FlagAssignmentsEnv, WithMyErr] r => SolvedPackage -> PkgList -> Bool -> Sem r PkgBuild
cabalToPkgBuild :: SolvedPackage -> PkgList -> Bool -> Sem r PkgBuild
cabalToPkgBuild SolvedPackage
pkg PkgList
ignored Bool
uusi = do
  let name :: PackageName
name = SolvedPackage
pkg SolvedPackage
-> Getting PackageName SolvedPackage PackageName -> PackageName
forall s a. s -> Getting a s a -> a
^. Getting PackageName SolvedPackage PackageName
Lens' SolvedPackage PackageName
pkgName
  PackageDescription
cabal <- GenericPackageDescription -> PackageDescription
packageDescription (GenericPackageDescription -> PackageDescription)
-> Sem r GenericPackageDescription -> Sem r PackageDescription
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (PackageName -> Sem r GenericPackageDescription
forall (r :: [Effect]).
Members '[HackageEnv, WithMyErr] r =>
PackageName -> Sem r GenericPackageDescription
getLatestCabal PackageName
name)
  String
_sha256sums <- (\String
s -> String
"'" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
s String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"'") (String -> String) -> Sem r String -> Sem r String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PackageName -> Sem r String
forall (r :: [Effect]).
Members '[HackageEnv, WithMyErr] r =>
PackageName -> Sem r String
getLatestSHA256 PackageName
name
  let _hkgName :: String
_hkgName = SolvedPackage
pkg SolvedPackage
-> Getting PackageName SolvedPackage PackageName -> PackageName
forall s a. s -> Getting a s a -> a
^. Getting PackageName SolvedPackage PackageName
Lens' SolvedPackage PackageName
pkgName PackageName -> (PackageName -> String) -> String
forall a b. a -> (a -> b) -> b
& PackageName -> String
unPackageName
      rawName :: String
rawName = String -> String
toLower' String
_hkgName
      _pkgName :: String
_pkgName = String -> (String -> String) -> Maybe String -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
rawName String -> String
forall a. a -> a
id (Maybe String -> String) -> Maybe String -> String
forall a b. (a -> b) -> a -> b
$ String -> String -> Maybe String
forall a. Eq a => [a] -> [a] -> Maybe [a]
stripPrefix String
"haskell-" String
rawName
      _pkgVer :: String
_pkgVer = Version -> String
forall a. Pretty a => a -> String
prettyShow (Version -> String) -> Version -> String
forall a b. (a -> b) -> a -> b
$ PackageDescription -> Version
getPkgVersion PackageDescription
cabal
      _pkgDesc :: String
_pkgDesc = ShortText -> String
fromShortText (ShortText -> String) -> ShortText -> String
forall a b. (a -> b) -> a -> b
$ PackageDescription -> ShortText
synopsis PackageDescription
cabal
      getL :: License -> String
getL (License
NONE) = String
""
      getL (License LicenseExpression
e) = LicenseExpression -> String
getE LicenseExpression
e
      getE :: LicenseExpression -> String
getE (ELicense (ELicenseId LicenseId
x) Maybe LicenseExceptionId
_) = ArchLicense -> String
forall a. Show a => a -> String
show (ArchLicense -> String)
-> (LicenseId -> ArchLicense) -> LicenseId -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LicenseId -> ArchLicense
mapLicense (LicenseId -> String) -> LicenseId -> String
forall a b. (a -> b) -> a -> b
$ LicenseId
x
      getE (ELicense (ELicenseIdPlus LicenseId
x) Maybe LicenseExceptionId
_) = ArchLicense -> String
forall a. Show a => a -> String
show (ArchLicense -> String)
-> (LicenseId -> ArchLicense) -> LicenseId -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LicenseId -> ArchLicense
mapLicense (LicenseId -> String) -> LicenseId -> String
forall a b. (a -> b) -> a -> b
$ LicenseId
x
      getE (ELicense (ELicenseRef LicenseRef
x) Maybe LicenseExceptionId
_) = String
"custom:" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> LicenseRef -> String
licenseRef LicenseRef
x
      getE (EAnd LicenseExpression
x LicenseExpression
y) = LicenseExpression -> String
getE LicenseExpression
x String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
" " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> LicenseExpression -> String
getE LicenseExpression
y
      getE (EOr LicenseExpression
x LicenseExpression
y) = LicenseExpression -> String
getE LicenseExpression
x String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
" " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> LicenseExpression -> String
getE LicenseExpression
y

      _license :: String
_license = License -> String
getL (License -> String)
-> (PackageDescription -> License) -> PackageDescription -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageDescription -> License
license (PackageDescription -> String) -> PackageDescription -> String
forall a b. (a -> b) -> a -> b
$ PackageDescription
cabal
      _enableCheck :: Bool
_enableCheck = (Bool -> Bool) -> [Bool] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Bool -> Bool
forall a. a -> a
id ([Bool] -> Bool) -> [Bool] -> Bool
forall a b. (a -> b) -> a -> b
$ SolvedPackage
pkg SolvedPackage
-> Getting [SolvedDependency] SolvedPackage [SolvedDependency]
-> [SolvedDependency]
forall s a. s -> Getting a s a -> a
^. Getting [SolvedDependency] SolvedPackage [SolvedDependency]
Traversal' SolvedPackage [SolvedDependency]
pkgDeps [SolvedDependency] -> ([SolvedDependency] -> [Bool]) -> [Bool]
forall a b. a -> (a -> b) -> b
& ASetter [SolvedDependency] [Bool] SolvedDependency Bool
forall (f :: * -> *) a b. Functor f => ASetter (f a) (f b) a b
mapped ASetter [SolvedDependency] [Bool] SolvedDependency Bool
-> (SolvedDependency -> Bool) -> [SolvedDependency] -> [Bool]
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ (\SolvedDependency
dep -> DependencyKind -> SolvedDependency -> Bool
selectDepKind DependencyKind
Test SolvedDependency
dep Bool -> Bool -> Bool
&& SolvedDependency
dep SolvedDependency
-> Getting PackageName SolvedDependency PackageName -> PackageName
forall s a. s -> Getting a s a -> a
^. Getting PackageName SolvedDependency PackageName
Lens' SolvedDependency PackageName
depName PackageName -> PackageName -> Bool
forall a. Eq a => a -> a -> Bool
== SolvedPackage
pkg SolvedPackage
-> Getting PackageName SolvedPackage PackageName -> PackageName
forall s a. s -> Getting a s a -> a
^. Getting PackageName SolvedPackage PackageName
Lens' SolvedPackage PackageName
pkgName)
      depends :: [SolvedDependency]
depends =
        SolvedPackage
pkg SolvedPackage
-> Getting [SolvedDependency] SolvedPackage [SolvedDependency]
-> [SolvedDependency]
forall s a. s -> Getting a s a -> a
^. Getting [SolvedDependency] SolvedPackage [SolvedDependency]
Traversal' SolvedPackage [SolvedDependency]
pkgDeps
          [SolvedDependency]
-> Getting
     (Endo [SolvedDependency]) [SolvedDependency] SolvedDependency
-> [SolvedDependency]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. Getting
  (Endo [SolvedDependency]) [SolvedDependency] SolvedDependency
forall s t a b. Each s t a b => Traversal s t a b
each
            Getting
  (Endo [SolvedDependency]) [SolvedDependency] SolvedDependency
-> ((SolvedDependency
     -> Const (Endo [SolvedDependency]) SolvedDependency)
    -> SolvedDependency
    -> Const (Endo [SolvedDependency]) SolvedDependency)
-> Getting
     (Endo [SolvedDependency]) [SolvedDependency] SolvedDependency
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SolvedDependency -> Bool)
-> Traversal' SolvedDependency SolvedDependency
forall a. (a -> Bool) -> Traversal' a a
filtered
              ( \SolvedDependency
x ->
                  SolvedDependency -> Bool
notMyself SolvedDependency
x
                    Bool -> Bool -> Bool
&& SolvedDependency -> Bool
notInGHCLib SolvedDependency
x
                    Bool -> Bool -> Bool
&& ( DependencyKind -> SolvedDependency -> Bool
selectDepKind DependencyKind
Lib SolvedDependency
x
                           Bool -> Bool -> Bool
|| DependencyKind -> SolvedDependency -> Bool
selectDepKind DependencyKind
Exe SolvedDependency
x
                           Bool -> Bool -> Bool
|| DependencyKind -> SolvedDependency -> Bool
selectDepKind DependencyKind
SubLibs SolvedDependency
x
                       )
                    Bool -> Bool -> Bool
&& SolvedDependency -> Bool
notIgnore SolvedDependency
x
              )
      makeDepends :: [SolvedDependency]
makeDepends =
        SolvedPackage
pkg SolvedPackage
-> Getting [SolvedDependency] SolvedPackage [SolvedDependency]
-> [SolvedDependency]
forall s a. s -> Getting a s a -> a
^. Getting [SolvedDependency] SolvedPackage [SolvedDependency]
Traversal' SolvedPackage [SolvedDependency]
pkgDeps
          [SolvedDependency]
-> Getting
     (Endo [SolvedDependency]) [SolvedDependency] SolvedDependency
-> [SolvedDependency]
forall s a. s -> Getting (Endo [a]) s a -> [a]
^.. Getting
  (Endo [SolvedDependency]) [SolvedDependency] SolvedDependency
forall s t a b. Each s t a b => Traversal s t a b
each
            Getting
  (Endo [SolvedDependency]) [SolvedDependency] SolvedDependency
-> ((SolvedDependency
     -> Const (Endo [SolvedDependency]) SolvedDependency)
    -> SolvedDependency
    -> Const (Endo [SolvedDependency]) SolvedDependency)
-> Getting
     (Endo [SolvedDependency]) [SolvedDependency] SolvedDependency
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SolvedDependency -> Bool)
-> Traversal' SolvedDependency SolvedDependency
forall a. (a -> Bool) -> Traversal' a a
filtered
              ( \SolvedDependency
x ->
                  SolvedDependency
x SolvedDependency -> [SolvedDependency] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [SolvedDependency]
depends
                    Bool -> Bool -> Bool
&& SolvedDependency -> Bool
notMyself SolvedDependency
x
                    Bool -> Bool -> Bool
&& SolvedDependency -> Bool
notInGHCLib SolvedDependency
x
                    Bool -> Bool -> Bool
&& ( DependencyKind -> SolvedDependency -> Bool
selectDepKind DependencyKind
LibBuildTools SolvedDependency
x
                           Bool -> Bool -> Bool
|| DependencyKind -> SolvedDependency -> Bool
selectDepKind DependencyKind
Test SolvedDependency
x
                           Bool -> Bool -> Bool
|| DependencyKind -> SolvedDependency -> Bool
selectDepKind DependencyKind
TestBuildTools SolvedDependency
x
                           Bool -> Bool -> Bool
|| DependencyKind -> SolvedDependency -> Bool
selectDepKind DependencyKind
SubLibsBuildTools SolvedDependency
x
                       )
                    Bool -> Bool -> Bool
&& SolvedDependency -> Bool
notIgnore SolvedDependency
x
              )
      depsToString :: [SolvedDependency] -> String
depsToString [SolvedDependency]
deps = [SolvedDependency]
deps [SolvedDependency] -> (SolvedDependency -> String) -> [String]
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (String -> String
wrap (String -> String)
-> (SolvedDependency -> String) -> SolvedDependency -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
fixName (String -> String)
-> (SolvedDependency -> String) -> SolvedDependency -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageName -> String
unPackageName (PackageName -> String)
-> (SolvedDependency -> PackageName) -> SolvedDependency -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SolvedDependency -> PackageName
_depName) [String] -> ([String] -> String) -> String
forall a b. a -> (a -> b) -> b
& [String] -> String
forall a. Monoid a => [a] -> a
mconcat
      _depends :: String
_depends = [SolvedDependency] -> String
depsToString [SolvedDependency]
depends
      _makeDepends :: String
_makeDepends = (if Bool
uusi then String
" 'uusi'" else String
"") String -> String -> String
forall a. Semigroup a => a -> a -> a
<> [SolvedDependency] -> String
depsToString [SolvedDependency]
makeDepends
      _url :: String
_url = PackageDescription -> String
getUrl PackageDescription
cabal
      wrap :: String -> String
wrap String
s = String
" '" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
s String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"'"
      notInGHCLib :: SolvedDependency -> Bool
notInGHCLib SolvedDependency
x = (SolvedDependency
x SolvedDependency
-> Getting PackageName SolvedDependency PackageName -> PackageName
forall s a. s -> Getting a s a -> a
^. Getting PackageName SolvedDependency PackageName
Lens' SolvedDependency PackageName
depName) PackageName -> PkgList -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` PkgList
ghcLibList
      notMyself :: SolvedDependency -> Bool
notMyself SolvedDependency
x = SolvedDependency
x SolvedDependency
-> Getting PackageName SolvedDependency PackageName -> PackageName
forall s a. s -> Getting a s a -> a
^. Getting PackageName SolvedDependency PackageName
Lens' SolvedDependency PackageName
depName PackageName -> PackageName -> Bool
forall a. Eq a => a -> a -> Bool
/= PackageName
name
      notIgnore :: SolvedDependency -> Bool
notIgnore SolvedDependency
x = SolvedDependency
x SolvedDependency
-> Getting PackageName SolvedDependency PackageName -> PackageName
forall s a. s -> Getting a s a -> a
^. Getting PackageName SolvedDependency PackageName
Lens' SolvedDependency PackageName
depName PackageName -> PkgList -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` PkgList
ignored
      selectDepKind :: DependencyKind -> SolvedDependency -> Bool
selectDepKind DependencyKind
k SolvedDependency
x = DependencyKind
k DependencyKind -> [DependencyKind] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (SolvedDependency
x SolvedDependency
-> Getting [DependencyType] SolvedDependency [DependencyType]
-> [DependencyType]
forall s a. s -> Getting a s a -> a
^. Getting [DependencyType] SolvedDependency [DependencyType]
Lens' SolvedDependency [DependencyType]
depType [DependencyType]
-> ([DependencyType] -> [DependencyKind]) -> [DependencyKind]
forall a b. a -> (a -> b) -> b
& ASetter
  [DependencyType] [DependencyKind] DependencyType DependencyKind
forall (f :: * -> *) a b. Functor f => ASetter (f a) (f b) a b
mapped ASetter
  [DependencyType] [DependencyKind] DependencyType DependencyKind
-> (DependencyType -> DependencyKind)
-> [DependencyType]
-> [DependencyKind]
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ DependencyType -> DependencyKind
dependencyTypeToKind)
      _licenseFile :: Maybe String
_licenseFile = PackageDescription -> [String]
licenseFiles PackageDescription
cabal [String] -> Getting (First String) [String] String -> Maybe String
forall s a. s -> Getting (First a) s a -> Maybe a
^? Index [String] -> Traversal' [String] (IxValue [String])
forall m. Ixed m => Index m -> Traversal' m (IxValue m)
ix Index [String]
0
      _enableUusi :: Bool
_enableUusi = Bool
uusi
  PkgBuild -> Sem r PkgBuild
forall (m :: * -> *) a. Monad m => a -> m a
return PkgBuild :: String
-> String
-> String
-> String
-> String
-> String
-> String
-> String
-> String
-> Maybe String
-> Bool
-> Bool
-> PkgBuild
PkgBuild {Bool
String
Maybe String
_enableCheck :: Bool
_enableUusi :: Bool
_licenseFile :: Maybe String
_sha256sums :: String
_makeDepends :: String
_depends :: String
_license :: String
_url :: String
_pkgDesc :: String
_pkgVer :: String
_pkgName :: String
_hkgName :: String
_enableUusi :: Bool
_licenseFile :: Maybe String
_url :: String
_makeDepends :: String
_depends :: String
_enableCheck :: Bool
_license :: String
_pkgDesc :: String
_pkgVer :: String
_pkgName :: String
_hkgName :: String
_sha256sums :: String
..}