{-# LANGUAGE NoImplicitPrelude   #-}
{-# LANGUAGE NoFieldSelectors    #-}
{-# LANGUAGE OverloadedRecordDot #-}

module Stack.Types.DumpPackage
  ( DumpPackage (..)
  , SublibDump (..)
  , dpParentLibIdent
  ) where

import qualified Distribution.License as C
import           Distribution.ModuleName ( ModuleName )
import           Stack.Prelude
import           Stack.Types.Component ( StackUnqualCompName )
import           Stack.Types.GhcPkgId ( GhcPkgId )

-- | Type representing dump information for a single package, as output by the

-- @ghc-pkg describe@ command.

data DumpPackage = DumpPackage
  { DumpPackage -> GhcPkgId
ghcPkgId :: !GhcPkgId
    -- ^ The @id@ field.

  , DumpPackage -> PackageIdentifier
packageIdent :: !PackageIdentifier
    -- ^ The @name@ and @version@ fields. The @name@ field is the munged package

    -- name. If the package is not for a sub library, its munged name is its

    -- name.

  , DumpPackage -> Maybe SublibDump
sublib :: !(Maybe SublibDump)
    -- ^ The sub library information if it's a sub-library.

  , DumpPackage -> Maybe License
license :: !(Maybe C.License)
  , DumpPackage -> [FilePath]
libDirs :: ![FilePath]
    -- ^ The @library-dirs@ field.

  , DumpPackage -> [Text]
libraries :: ![Text]
    -- ^ The @hs-libraries@ field.

  , DumpPackage -> Bool
hasExposedModules :: !Bool
  , DumpPackage -> Set ModuleName
exposedModules :: !(Set ModuleName)
  , DumpPackage -> [GhcPkgId]
depends :: ![GhcPkgId]
    -- ^ The @depends@ field (packages on which this package depends).

  , DumpPackage -> [FilePath]
haddockInterfaces :: ![FilePath]
  , DumpPackage -> Maybe FilePath
haddockHtml :: !(Maybe FilePath)
  , DumpPackage -> Bool
isExposed :: !Bool
  }
  deriving (DumpPackage -> DumpPackage -> Bool
(DumpPackage -> DumpPackage -> Bool)
-> (DumpPackage -> DumpPackage -> Bool) -> Eq DumpPackage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DumpPackage -> DumpPackage -> Bool
== :: DumpPackage -> DumpPackage -> Bool
$c/= :: DumpPackage -> DumpPackage -> Bool
/= :: DumpPackage -> DumpPackage -> Bool
Eq, ReadPrec [DumpPackage]
ReadPrec DumpPackage
Int -> ReadS DumpPackage
ReadS [DumpPackage]
(Int -> ReadS DumpPackage)
-> ReadS [DumpPackage]
-> ReadPrec DumpPackage
-> ReadPrec [DumpPackage]
-> Read DumpPackage
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DumpPackage
readsPrec :: Int -> ReadS DumpPackage
$creadList :: ReadS [DumpPackage]
readList :: ReadS [DumpPackage]
$creadPrec :: ReadPrec DumpPackage
readPrec :: ReadPrec DumpPackage
$creadListPrec :: ReadPrec [DumpPackage]
readListPrec :: ReadPrec [DumpPackage]
Read, Int -> DumpPackage -> ShowS
[DumpPackage] -> ShowS
DumpPackage -> FilePath
(Int -> DumpPackage -> ShowS)
-> (DumpPackage -> FilePath)
-> ([DumpPackage] -> ShowS)
-> Show DumpPackage
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DumpPackage -> ShowS
showsPrec :: Int -> DumpPackage -> ShowS
$cshow :: DumpPackage -> FilePath
show :: DumpPackage -> FilePath
$cshowList :: [DumpPackage] -> ShowS
showList :: [DumpPackage] -> ShowS
Show)

-- | ghc-pkg has a notion of sublibraries when using ghc-pkg dump. We can only

-- know it's different through the fields it shows.

data SublibDump = SublibDump
  { SublibDump -> PackageName
packageName :: PackageName
    -- ^ "package-name" field from ghc-pkg

  , SublibDump -> StackUnqualCompName
libraryName :: StackUnqualCompName
    -- ^ "lib-name" field from ghc-pkg

  }
  deriving (SublibDump -> SublibDump -> Bool
(SublibDump -> SublibDump -> Bool)
-> (SublibDump -> SublibDump -> Bool) -> Eq SublibDump
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SublibDump -> SublibDump -> Bool
== :: SublibDump -> SublibDump -> Bool
$c/= :: SublibDump -> SublibDump -> Bool
/= :: SublibDump -> SublibDump -> Bool
Eq, ReadPrec [SublibDump]
ReadPrec SublibDump
Int -> ReadS SublibDump
ReadS [SublibDump]
(Int -> ReadS SublibDump)
-> ReadS [SublibDump]
-> ReadPrec SublibDump
-> ReadPrec [SublibDump]
-> Read SublibDump
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SublibDump
readsPrec :: Int -> ReadS SublibDump
$creadList :: ReadS [SublibDump]
readList :: ReadS [SublibDump]
$creadPrec :: ReadPrec SublibDump
readPrec :: ReadPrec SublibDump
$creadListPrec :: ReadPrec [SublibDump]
readListPrec :: ReadPrec [SublibDump]
Read, Int -> SublibDump -> ShowS
[SublibDump] -> ShowS
SublibDump -> FilePath
(Int -> SublibDump -> ShowS)
-> (SublibDump -> FilePath)
-> ([SublibDump] -> ShowS)
-> Show SublibDump
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SublibDump -> ShowS
showsPrec :: Int -> SublibDump -> ShowS
$cshow :: SublibDump -> FilePath
show :: SublibDump -> FilePath
$cshowList :: [SublibDump] -> ShowS
showList :: [SublibDump] -> ShowS
Show)

dpParentLibIdent :: DumpPackage -> Maybe PackageIdentifier
dpParentLibIdent :: DumpPackage -> Maybe PackageIdentifier
dpParentLibIdent DumpPackage
dp = case (DumpPackage
dp.sublib, DumpPackage
dp.packageIdent) of
  (Maybe SublibDump
Nothing, PackageIdentifier
_) -> Maybe PackageIdentifier
forall a. Maybe a
Nothing
  (Just SublibDump
sublibDump, PackageIdentifier PackageName
_ Version
v) ->
    PackageIdentifier -> Maybe PackageIdentifier
forall a. a -> Maybe a
Just (PackageIdentifier -> Maybe PackageIdentifier)
-> PackageIdentifier -> Maybe PackageIdentifier
forall a b. (a -> b) -> a -> b
$ PackageName -> Version -> PackageIdentifier
PackageIdentifier PackageName
libParentPackageName Version
v
   where
    SublibDump { $sel:packageName:SublibDump :: SublibDump -> PackageName
packageName = PackageName
libParentPackageName } = SublibDump
sublibDump