{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeApplications #-}

-- | 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.Char (toLower)
import qualified Data.Map as Map
import Data.Set (Set)
import qualified Data.Set as Set
import Distribution.ArchHs.Exception
import Distribution.ArchHs.Hackage
  ( getLatestCabal,
    getLatestSHA256,
  )
import Distribution.ArchHs.Internal.Prelude
import Distribution.ArchHs.Local (ghcLibList, ignoreList)
import Distribution.ArchHs.Name
import Distribution.ArchHs.PkgBuild
  ( PkgBuild (..),
    mapLicense,
  )
import Distribution.ArchHs.Types
import Distribution.ArchHs.Utils
import Distribution.Compiler (CompilerFlavor (..))
import Distribution.PackageDescription
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.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 <- (\case Just 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
"'"; Maybe String
Nothing -> String
"'SKIP'") (Maybe String -> String) -> Sem r (Maybe String) -> Sem r String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PackageName -> Sem r (Maybe String)
forall (r :: [Effect]).
Members '[HackageEnv, WithMyErr] r =>
PackageName -> Sem r (Maybe 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 = Char -> Char
toLower (Char -> Char) -> String -> String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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
. CommunityName -> String
unCommunityName (CommunityName -> String)
-> (SolvedDependency -> CommunityName)
-> SolvedDependency
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageName -> CommunityName
forall n. HasMyName n => n -> CommunityName
toCommunityName (PackageName -> CommunityName)
-> (SolvedDependency -> PackageName)
-> SolvedDependency
-> CommunityName
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
..}