{-# LANGUAGE CPP #-}

module SimpleCabal (
  findCabalFile,
  findCabalFile',
  readFinalPackageDescription,
  readFinalPackageDescription',
  finalPackageDescription,
#if MIN_VERSION_Cabal(2,2,0)
  parseFinalPackageDescription,
#endif
  makeFinalPackageDescription,
  getPackageId,
--  dependencies,
#if MIN_VERSION_Cabal(2,4,0)
  buildDepends,
#endif
  buildDependencies,
  setupDependencies,
  testsuiteDependencies,

  allBuildInfo, -- deprecated by allLibraries et al
  allLibraries,
  BuildInfo (..),
  Library(..),
  depPkgName, exeDepName, pkgcfgDepName,
#if MIN_VERSION_Cabal(2,0,0)
  UnqualComponentName, mkUnqualComponentName,
#endif
  unUnqualComponentName,
  FlagName, mkFlagName,
  hasExes, hasLibs,
#if !MIN_VERSION_Cabal(1,20,0)
  licenseFiles,
#endif
  PackageDescription (..),
  PackageIdentifier (..),
  PackageName, mkPackageName, unPackageName,
  packageName, packageVersion,
  readGenericPackageDescription',
  showPkgId,
  showVersion,
  simpleParse,
#if MIN_VERSION_Cabal(2,2,0)
  simpleParsec,
#endif
  tryFindPackageDesc,
  tryFindPackageDesc'
  ) where

#if MIN_VERSION_base(4,8,0)
#else
import Control.Applicative ((<$>))
#endif

#if MIN_VERSION_Cabal(2,2,0)
import qualified Data.ByteString.Char8 as B
#endif
import Data.Maybe (
  listToMaybe,
#if !MIN_VERSION_Cabal(2,0,0)
  maybeToList
#endif
    )
import Data.List (delete, nub)

#if MIN_VERSION_Cabal(3,16,0)
import Distribution.Types.DependencySatisfaction
#endif

import Distribution.Compiler
import Distribution.Package  (
                              packageName,
#if MIN_VERSION_Cabal(1,22,0)
#if MIN_VERSION_Cabal(2,0,0)
                              depPkgName,
                              mkPackageName,
                              unPackageName,
                              unPkgconfigName,
#if MIN_VERSION_Cabal(2,4,0)
                              Dependency,
#endif
#else
#endif
#endif
#if MIN_VERSION_Cabal(2,0,0)
#else
                              Dependency (..),
#endif
#if MIN_VERSION_Cabal(2,0,0)
                              PackageName,
#else
                              PackageName (..),
#endif
                              PackageIdentifier (..),
                                       )

import Distribution.PackageDescription (
  PackageDescription (..),
  allBuildInfo,
#if MIN_VERSION_Cabal(2,0,0)
  allLibraries,
#endif
  BuildInfo (..),
--  buildToolDepends,
#if MIN_VERSION_Cabal(2,4,0)
  enabledBuildDepends,
#endif
  extraLibs,
#if MIN_VERSION_Cabal(2,0,0)
  FlagName,
  mkFlagName,
#else
  FlagName (..),
#endif
  GenericPackageDescription(packageDescription),
  hasExes, hasLibs,
  Library(..),
#if MIN_VERSION_Cabal(2,2,0)
  mkFlagAssignment,
#endif
  pkgconfigDepends,
#if MIN_VERSION_Cabal(1,24,0)
  setupDepends,
#endif
  targetBuildDepends,
  TestSuite (..)
  )
#if MIN_VERSION_Cabal(2,0,0)
import Distribution.PackageDescription.Configuration (finalizePD)
import Distribution.Types.ComponentRequestedSpec (defaultComponentRequestedSpec)
import Distribution.Types.LegacyExeDependency (LegacyExeDependency (..))
import Distribution.Types.PkgconfigDependency (PkgconfigDependency (..))
import Distribution.Types.UnqualComponentName (UnqualComponentName(),
                                               mkUnqualComponentName,
                                               unUnqualComponentName
                                              )
#else
import Distribution.PackageDescription.Configuration (finalizePackageDescription)
#endif
#if MIN_VERSION_Cabal(2,2,0)
import qualified Distribution.PackageDescription.Parsec as DPP
#elif MIN_VERSION_Cabal(2,0,0)
import qualified Distribution.PackageDescription.Parse as DPP
#else
import qualified Distribution.PackageDescription.Parse as DPP
#endif

#if MIN_VERSION_Cabal(3,0,0)
import Distribution.Parsec (simpleParsec)
#else
#if MIN_VERSION_Cabal(2,2,0)
import Distribution.Parsec.Class (simpleParsec)
#endif
#endif

import Distribution.Simple.Compiler (
#if MIN_VERSION_Cabal(1,22,0)
    compilerInfo
#else
    Compiler (..)
#endif
    )
import Distribution.Simple.Configure (
#if MIN_VERSION_Cabal(1,18,0)
    configCompilerEx
#else
    configCompiler
#endif
    )
#if MIN_VERSION_Cabal(3,8,0)
import qualified Distribution.Simple.PackageDescription as DSP
#endif
#if MIN_VERSION_Cabal(2,0,0)
--import Distribution.Simple.BuildToolDepends (getAllToolDependencies)
import Distribution.Simple.Program   (defaultProgramDb)
#else
import Distribution.Simple.Program   (defaultProgramConfiguration)
#endif
#if MIN_VERSION_Cabal(3,14,0)
import Distribution.Utils.Path (interpretSymbolicPath, makeSymbolicPath)
#endif
import qualified Distribution.Simple.Utils as DSU (
#if MIN_VERSION_Cabal(1,20,0)
    tryFindPackageDesc
#else
    findPackageDesc
#endif
    )
import Distribution.System (Platform (..), buildArch, buildOS)

import Distribution.Text (simpleParse)

import Distribution.Verbosity (normal, Verbosity
                              )

#if MIN_VERSION_Cabal(2,2,0)
import Distribution.Pretty (prettyShow)
#else
#if MIN_VERSION_Cabal(2,0,0)
import Distribution.Version (showVersion)
#else
import Data.Version (showVersion)
#endif
#endif

#if MIN_VERSION_Cabal(2,2,0)
import qualified Distribution.Version (Version)
#endif

import System.Directory (getDirectoryContents,
#if MIN_VERSION_directory(1,3,9)
                         withCurrentDirectory
#endif
                        )
import System.FilePath (normalise, takeExtension, (</>))

-- | Find the .cabal file in the current directory.
--
-- Errors if more than one or no file found.
--
-- @since 0.0.0.1
findCabalFile :: IO FilePath
findCabalFile :: IO FilePath
findCabalFile = FilePath -> IO FilePath
findCabalFile' FilePath
"."

-- | Find .cabal file in a directory
--
-- Errors if more than one or no file found.
--
-- @since 0.2.1
findCabalFile' :: FilePath -> IO FilePath
findCabalFile' :: FilePath -> IO FilePath
findCabalFile' FilePath
dir = do
  [FilePath]
allCabals <- FilePath -> IO [FilePath]
filesWithExtension FilePath
".cabal"
  case [FilePath]
allCabals of
    [FilePath
file] -> FilePath -> IO FilePath
forall (m :: * -> *) a. Monad m => a -> m a
return (FilePath -> IO FilePath) -> FilePath -> IO FilePath
forall a b. (a -> b) -> a -> b
$ FilePath -> FilePath
normalise (FilePath -> FilePath) -> FilePath -> FilePath
forall a b. (a -> b) -> a -> b
$ FilePath
dir FilePath -> FilePath -> FilePath
</> FilePath
file
    [] -> FilePath -> IO FilePath
forall a. HasCallStack => FilePath -> a
error FilePath
"No .cabal file found"
    [FilePath]
_ -> FilePath -> IO FilePath
forall a. HasCallStack => FilePath -> a
error FilePath
"More than one .cabal file found!"
  where
    filesWithExtension :: String -> IO [FilePath]
    filesWithExtension :: FilePath -> IO [FilePath]
filesWithExtension FilePath
ext =
      (FilePath -> Bool) -> [FilePath] -> [FilePath]
forall a. (a -> Bool) -> [a] -> [a]
filter (\ FilePath
f -> FilePath -> FilePath
takeExtension FilePath
f FilePath -> FilePath -> Bool
forall a. Eq a => a -> a -> Bool
== FilePath
ext Bool -> Bool -> Bool
&& FilePath -> Maybe Char
forall a. [a] -> Maybe a
listToMaybe FilePath
f Maybe Char -> Maybe Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char -> Maybe Char
forall a. a -> Maybe a
Just Char
'.')
      ([FilePath] -> [FilePath]) -> IO [FilePath] -> IO [FilePath]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FilePath -> IO [FilePath]
getDirectoryContents FilePath
dir

-- | Get the package name-version from the .cabal file in the current directory.
--
-- @since 0.0.0.1
getPackageId :: IO PackageIdentifier
getPackageId :: IO PackageIdentifier
getPackageId = do
  GenericPackageDescription
gpd <- IO FilePath
findCabalFile IO FilePath
-> (FilePath -> IO GenericPackageDescription)
-> IO GenericPackageDescription
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Verbosity -> FilePath -> IO GenericPackageDescription
readGenericPackageDescription' Verbosity
normal
  PackageIdentifier -> IO PackageIdentifier
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageIdentifier -> IO PackageIdentifier)
-> PackageIdentifier -> IO PackageIdentifier
forall a b. (a -> b) -> a -> b
$ PackageDescription -> PackageIdentifier
package (PackageDescription -> PackageIdentifier)
-> PackageDescription -> PackageIdentifier
forall a b. (a -> b) -> a -> b
$ GenericPackageDescription -> PackageDescription
packageDescription GenericPackageDescription
gpd

#if MIN_VERSION_Cabal(2,2,0)
-- | only available with Cabal-2.2+
--
-- @since 0.1.2
parseFinalPackageDescription :: [(FlagName, Bool)] -> B.ByteString
                          -> IO (Maybe PackageDescription)
parseFinalPackageDescription :: [(FlagName, Bool)] -> ByteString -> IO (Maybe PackageDescription)
parseFinalPackageDescription [(FlagName, Bool)]
flags ByteString
cabalfile = do
  let mgenPkgDesc :: Maybe GenericPackageDescription
mgenPkgDesc = ByteString -> Maybe GenericPackageDescription
DPP.parseGenericPackageDescriptionMaybe ByteString
cabalfile
  case Maybe GenericPackageDescription
mgenPkgDesc of
    Maybe GenericPackageDescription
Nothing -> Maybe PackageDescription -> IO (Maybe PackageDescription)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PackageDescription
forall a. Maybe a
Nothing
    Just GenericPackageDescription
genPkgDesc -> PackageDescription -> Maybe PackageDescription
forall a. a -> Maybe a
Just (PackageDescription -> Maybe PackageDescription)
-> IO PackageDescription -> IO (Maybe PackageDescription)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(FlagName, Bool)]
-> GenericPackageDescription -> IO PackageDescription
makeFinalPackageDescription [(FlagName, Bool)]
flags GenericPackageDescription
genPkgDesc
#endif

-- | Generate PackageDescription from the specified .cabal file and flags.
--
-- deprecated in favour of readFinalPackageDescription
--
-- @since 0.0.0.1
finalPackageDescription :: [(FlagName, Bool)] -> FilePath
                          -> IO PackageDescription
finalPackageDescription :: [(FlagName, Bool)] -> FilePath -> IO PackageDescription
finalPackageDescription = [(FlagName, Bool)] -> FilePath -> IO PackageDescription
readFinalPackageDescription

-- | Legacy version of readGenericPackageDescription
-- which doesn't use SymbolicPath (or workdir)
--
-- since 0.2.0
readGenericPackageDescription' :: Verbosity -> FilePath -> IO GenericPackageDescription
readGenericPackageDescription' :: Verbosity -> FilePath -> IO GenericPackageDescription
readGenericPackageDescription' Verbosity
verb FilePath
file =
#if MIN_VERSION_Cabal(3,8,0)
  DSP.readGenericPackageDescription verb
#elif MIN_VERSION_Cabal(2,0,0)
  Verbosity -> FilePath -> IO GenericPackageDescription
DPP.readGenericPackageDescription Verbosity
verb
#else
  DPP.readPackageDescription verb
#endif
--  DPP.readGenericPackageDescription verb
#if MIN_VERSION_Cabal(3,14,0)
    Nothing $
    makeSymbolicPath
#endif
    FilePath
file


-- | get PackageDescription from a cabal file
--
-- deprecates finalPackageDescription
--
-- @since 0.1.2
readFinalPackageDescription :: [(FlagName, Bool)] -> FilePath
                            -> IO PackageDescription
readFinalPackageDescription :: [(FlagName, Bool)] -> FilePath -> IO PackageDescription
readFinalPackageDescription [(FlagName, Bool)]
flags FilePath
cabalfile =
  Verbosity -> FilePath -> IO GenericPackageDescription
readGenericPackageDescription' Verbosity
normal FilePath
cabalfile IO GenericPackageDescription
-> (GenericPackageDescription -> IO PackageDescription)
-> IO PackageDescription
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
  [(FlagName, Bool)]
-> GenericPackageDescription -> IO PackageDescription
makeFinalPackageDescription [(FlagName, Bool)]
flags

-- | like readFinalPackageDescription but with a verbose parameter
--
-- @since 0.2.1
readFinalPackageDescription' :: [(FlagName, Bool)] -> Verbosity -> FilePath
                            -> IO PackageDescription
readFinalPackageDescription' :: [(FlagName, Bool)]
-> Verbosity -> FilePath -> IO PackageDescription
readFinalPackageDescription' [(FlagName, Bool)]
flags Verbosity
verbose FilePath
cabalfile =
  Verbosity -> FilePath -> IO GenericPackageDescription
readGenericPackageDescription' Verbosity
verbose FilePath
cabalfile IO GenericPackageDescription
-> (GenericPackageDescription -> IO PackageDescription)
-> IO PackageDescription
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
  [(FlagName, Bool)]
-> GenericPackageDescription -> IO PackageDescription
makeFinalPackageDescription [(FlagName, Bool)]
flags

-- | convert a GenericPackageDescription to a final PackageDescription
--
-- @since 0.1.2
makeFinalPackageDescription :: [(FlagName, Bool)] -> GenericPackageDescription
                            -> IO PackageDescription
makeFinalPackageDescription :: [(FlagName, Bool)]
-> GenericPackageDescription -> IO PackageDescription
makeFinalPackageDescription [(FlagName, Bool)]
flags GenericPackageDescription
genPkgDesc = do
#if !MIN_VERSION_Cabal(2,0,0)
  let defaultProgramDb = defaultProgramConfiguration
#endif
  CompilerInfo
compiler <- do
#if MIN_VERSION_Cabal(1,18,0)
    (Compiler
compiler, Platform
_, ProgramDb
_) <- Maybe CompilerFlavor
-> Maybe FilePath
-> Maybe FilePath
-> ProgramDb
-> Verbosity
-> IO (Compiler, Platform, ProgramDb)
configCompilerEx
#else
    (compiler, _) <- configCompiler
#endif
       (CompilerFlavor -> Maybe CompilerFlavor
forall a. a -> Maybe a
Just CompilerFlavor
GHC) Maybe FilePath
forall a. Maybe a
Nothing Maybe FilePath
forall a. Maybe a
Nothing ProgramDb
defaultProgramDb Verbosity
normal
#if MIN_VERSION_Cabal(1,22,0)
    CompilerInfo -> IO CompilerInfo
forall (m :: * -> *) a. Monad m => a -> m a
return (Compiler -> CompilerInfo
compilerInfo Compiler
compiler)
#else
    return (compilerId compiler)
#endif
#if !MIN_VERSION_Cabal(2,2,0)
  let mkFlagAssignment = id
#endif
#if MIN_VERSION_Cabal(2,0,0)
  let finalizePackageDescription :: FlagAssignment
-> (Dependency -> Bool)
-> Platform
-> CompilerInfo
-> [Dependency]
-> GenericPackageDescription
-> Either [Dependency] (PackageDescription, FlagAssignment)
finalizePackageDescription FlagAssignment
flags' = FlagAssignment
-> ComponentRequestedSpec
-> (Dependency -> Bool)
-> Platform
-> CompilerInfo
-> [Dependency]
-> GenericPackageDescription
-> Either [Dependency] (PackageDescription, FlagAssignment)
finalizePD FlagAssignment
flags' ComponentRequestedSpec
defaultComponentRequestedSpec
#endif
  let final :: Either [Dependency] (PackageDescription, FlagAssignment)
final =
        FlagAssignment
-> (Dependency -> Bool)
-> Platform
-> CompilerInfo
-> [Dependency]
-> GenericPackageDescription
-> Either [Dependency] (PackageDescription, FlagAssignment)
finalizePackageDescription ([(FlagName, Bool)] -> FlagAssignment
mkFlagAssignment [(FlagName, Bool)]
flags)
#if MIN_VERSION_Cabal(3,16,0)
        (const Satisfied)
#else
        (Bool -> Dependency -> Bool
forall a b. a -> b -> a
const Bool
True)
#endif
        (Arch -> OS -> Platform
Platform Arch
buildArch OS
buildOS)
        CompilerInfo
compiler
        [] GenericPackageDescription
genPkgDesc
  case Either [Dependency] (PackageDescription, FlagAssignment)
final of
    Left [Dependency]
e -> FilePath -> IO PackageDescription
forall a. HasCallStack => FilePath -> a
error (FilePath -> IO PackageDescription)
-> FilePath -> IO PackageDescription
forall a b. (a -> b) -> a -> b
$ FilePath
"finalize failed: " FilePath -> FilePath -> FilePath
forall a. [a] -> [a] -> [a]
++ [Dependency] -> FilePath
forall a. Show a => a -> FilePath
show [Dependency]
e
    Right (PackageDescription, FlagAssignment)
res -> PackageDescription -> IO PackageDescription
forall (m :: * -> *) a. Monad m => a -> m a
return (PackageDescription -> IO PackageDescription)
-> PackageDescription -> IO PackageDescription
forall a b. (a -> b) -> a -> b
$ (PackageDescription, FlagAssignment) -> PackageDescription
forall a b. (a, b) -> a
fst (PackageDescription, FlagAssignment)
res

-- | Return the list of build dependencies of a package, excluding itself
buildDependencies :: PackageDescription -> [PackageName]
buildDependencies :: PackageDescription -> [PackageName]
buildDependencies PackageDescription
pkgDesc =
  let deps :: [PackageName]
deps = [PackageName] -> [PackageName]
forall a. Eq a => [a] -> [a]
nub ([PackageName] -> [PackageName]) -> [PackageName] -> [PackageName]
forall a b. (a -> b) -> a -> b
$ (Dependency -> PackageName) -> [Dependency] -> [PackageName]
forall a b. (a -> b) -> [a] -> [b]
map Dependency -> PackageName
depPkgName (PackageDescription -> [Dependency]
buildDepends PackageDescription
pkgDesc)
      self :: PackageName
self = PackageIdentifier -> PackageName
pkgName (PackageIdentifier -> PackageName)
-> PackageIdentifier -> PackageName
forall a b. (a -> b) -> a -> b
$ PackageDescription -> PackageIdentifier
package PackageDescription
pkgDesc
  in PackageName -> [PackageName] -> [PackageName]
forall a. Eq a => a -> [a] -> [a]
delete PackageName
self [PackageName]
deps

-- | Return the list of testsuite dependencies of a package, excluding itself
testsuiteDependencies :: PackageDescription -> [PackageName]
testsuiteDependencies :: PackageDescription -> [PackageName]
testsuiteDependencies PackageDescription
pkgDesc =
  let self :: PackageName
self = PackageIdentifier -> PackageName
pkgName (PackageIdentifier -> PackageName)
-> PackageIdentifier -> PackageName
forall a b. (a -> b) -> a -> b
$ PackageDescription -> PackageIdentifier
package PackageDescription
pkgDesc in
  PackageName -> [PackageName] -> [PackageName]
forall a. Eq a => a -> [a] -> [a]
delete PackageName
self ([PackageName] -> [PackageName])
-> ([Dependency] -> [PackageName]) -> [Dependency] -> [PackageName]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [PackageName] -> [PackageName]
forall a. Eq a => [a] -> [a]
nub ([PackageName] -> [PackageName])
-> ([Dependency] -> [PackageName]) -> [Dependency] -> [PackageName]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Dependency -> PackageName) -> [Dependency] -> [PackageName]
forall a b. (a -> b) -> [a] -> [b]
map Dependency -> PackageName
depPkgName ([Dependency] -> [PackageName]) -> [Dependency] -> [PackageName]
forall a b. (a -> b) -> a -> b
$ (TestSuite -> [Dependency]) -> [TestSuite] -> [Dependency]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (BuildInfo -> [Dependency]
targetBuildDepends (BuildInfo -> [Dependency])
-> (TestSuite -> BuildInfo) -> TestSuite -> [Dependency]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TestSuite -> BuildInfo
testBuildInfo) (PackageDescription -> [TestSuite]
testSuites PackageDescription
pkgDesc)

-- | version string from PackageIdentifier
packageVersion :: PackageIdentifier -> String
packageVersion :: PackageIdentifier -> FilePath
packageVersion =
#if MIN_VERSION_Cabal(2,2,0)
  Version -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow (Version -> FilePath)
-> (PackageIdentifier -> Version) -> PackageIdentifier -> FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageIdentifier -> Version
pkgVersion
#else
  showVersion . pkgVersion
#endif

-- | convert PackageIdentifier to a displayable string
showPkgId :: PackageIdentifier -> String
showPkgId :: PackageIdentifier -> FilePath
showPkgId PackageIdentifier
pkgid =
#if MIN_VERSION_Cabal(2,2,0)
  PackageIdentifier -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow PackageIdentifier
pkgid
#else
  unPackageName (packageName pkgid) ++ "-" ++ packageVersion pkgid
#endif

#if !MIN_VERSION_Cabal(1,22,0)
unPackageName :: PackageName -> String
unPackageName (PackageName n) = n
#endif

#if MIN_VERSION_Cabal(2,2,0)
-- | render a Version
showVersion :: Distribution.Version.Version -> String
showVersion :: Version -> FilePath
showVersion = Version -> FilePath
forall a. Pretty a => a -> FilePath
prettyShow
#endif

#if !MIN_VERSION_Cabal(2,0,0)
mkFlagName :: String -> FlagName
mkFlagName = FlagName
#endif

-- | Find cabal file in directory
--
-- reintroduced in 0.2.1
tryFindPackageDesc :: FilePath -> IO FilePath
tryFindPackageDesc :: FilePath -> IO FilePath
tryFindPackageDesc FilePath
dir =
#if MIN_VERSION_Cabal(3,14,0)
  do
    file <- withCurrentDirectory dir $
      interpretSymbolicPath Nothing <$> DSU.tryFindPackageDesc normal Nothing
    return $ dir </> file
#elif MIN_VERSION_Cabal(3,0,0)
  Verbosity -> FilePath -> IO FilePath
DSU.tryFindPackageDesc Verbosity
normal FilePath
dir
#elif MIN_VERSION_Cabal(1,20,0)
  DSU.tryFindPackageDesc dir
#else
  DSU.findPackageDesc dir
#endif

-- | Find cabal file in current directory
tryFindPackageDesc' :: IO FilePath
tryFindPackageDesc' :: IO FilePath
tryFindPackageDesc' = FilePath -> IO FilePath
tryFindPackageDesc FilePath
"."

#if !MIN_VERSION_Cabal(1,20,0)
-- | singleton list of license file
licenseFiles :: PackageDescription -> [FilePath]
licenseFiles pkgDesc =
  [licenseFile pkgDesc | licenseFile pkgDesc /= ""]
#endif

#if MIN_VERSION_Cabal(2,4,0)
-- | List build dependencies
buildDepends :: PackageDescription -> [Dependency]
buildDepends :: PackageDescription -> [Dependency]
buildDepends = (PackageDescription -> ComponentRequestedSpec -> [Dependency])
-> ComponentRequestedSpec -> PackageDescription -> [Dependency]
forall a b c. (a -> b -> c) -> b -> a -> c
flip PackageDescription -> ComponentRequestedSpec -> [Dependency]
enabledBuildDepends ComponentRequestedSpec
defaultComponentRequestedSpec
#endif

#if MIN_VERSION_Cabal(2,0,0)
-- | name of legacy exe dep
exeDepName :: LegacyExeDependency -> String
exeDepName :: LegacyExeDependency -> FilePath
exeDepName (LegacyExeDependency FilePath
n VersionRange
_) = FilePath
n

-- | pkgconfig dep name
pkgcfgDepName :: PkgconfigDependency -> String
pkgcfgDepName :: PkgconfigDependency -> FilePath
pkgcfgDepName (PkgconfigDependency PkgconfigName
n PkgconfigVersionRange
_) = PkgconfigName -> FilePath
unPkgconfigName PkgconfigName
n
#else
-- | PackageName of dependency
depPkgName :: Dependency -> PackageName
depPkgName (Dependency pn _) = pn

-- | name of dependency
exeDepName :: Dependency -> String
exeDepName = unPackageName . depPkgName

-- | name of dependency
pkgcfgDepName :: Dependency -> String
pkgcfgDepName = unPackageName . depPkgName

-- | name of unqualified component
unUnqualComponentName :: String -> String
unUnqualComponentName = id
#endif

#if !MIN_VERSION_Cabal(2,0,0)
mkPackageName :: String -> PackageName
mkPackageName = PackageName
#endif

-- | List of setup dependencies
setupDependencies :: PackageDescription  -- ^pkg description
                  -> [PackageName]         -- ^depends
#if MIN_VERSION_Cabal(1,24,0)
setupDependencies :: PackageDescription -> [PackageName]
setupDependencies PackageDescription
pkgDesc =
  [PackageName]
-> (SetupBuildInfo -> [PackageName])
-> Maybe SetupBuildInfo
-> [PackageName]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] ((Dependency -> PackageName) -> [Dependency] -> [PackageName]
forall a b. (a -> b) -> [a] -> [b]
map Dependency -> PackageName
depPkgName ([Dependency] -> [PackageName])
-> (SetupBuildInfo -> [Dependency])
-> SetupBuildInfo
-> [PackageName]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SetupBuildInfo -> [Dependency]
setupDepends) (PackageDescription -> Maybe SetupBuildInfo
setupBuildInfo PackageDescription
pkgDesc)
#else
setupDependencies _pkgDesc = []
#endif

-- dependencies :: PackageDescription  -- ^pkg description
--                 -> ([PackageName], [PackageName], [ExeDependency], [String], [PkgconfigDependency])
--                 -- ^depends, setup, tools, c-libs, pkgcfg
-- dependencies pkgDesc =
--     let --self = pkgName $ package pkgDesc
--         deps = buildDependencies pkgDesc
--         setup = setupDependencies pkgDesc
--         buildinfo = allBuildInfo pkgDesc
--         tools =  nub $ concatMap buildToolDepends buildinfo
--         clibs = nub $ concatMap extraLibs buildinfo
--         pkgcfgs = nub $ concatMap pkgconfigDepends buildinfo
--     in (deps, setup, tools, clibs, pkgcfgs)

#if !MIN_VERSION_Cabal(2,0,0)
allLibraries :: PackageDescription -> [Library]
allLibraries = maybeToList . library
#endif