{-# LANGUAGE NoImplicitPrelude #-}
module Stack.Types.SourceMap
(
SMWanted (..)
, SMActual (..)
, Target (..)
, PackageType (..)
, SMTargets (..)
, SourceMap (..)
, FromSnapshot (..)
, DepPackage (..)
, ProjectPackage (..)
, CommonPackage (..)
, GlobalPackageVersion (..)
, GlobalPackage (..)
, isReplacedGlobal
, SourceMapHash (..)
, smRelDir
) where
import qualified Data.Text as T
import Distribution.PackageDescription ( GenericPackageDescription )
import qualified Pantry.SHA256 as SHA256
import Path
import Stack.Prelude
import Stack.Types.Compiler
import Stack.Types.NamedComponent
data CommonPackage = CommonPackage
{ CommonPackage -> IO GenericPackageDescription
cpGPD :: !(IO GenericPackageDescription)
, CommonPackage -> PackageName
cpName :: !PackageName
, CommonPackage -> Map FlagName Bool
cpFlags :: !(Map FlagName Bool)
, CommonPackage -> [Text]
cpGhcOptions :: ![Text]
, CommonPackage -> [Text]
cpCabalConfigOpts :: ![Text]
, CommonPackage -> Bool
cpHaddocks :: !Bool
}
data FromSnapshot
= FromSnapshot
| NotFromSnapshot
deriving (Int -> FromSnapshot -> ShowS
[FromSnapshot] -> ShowS
FromSnapshot -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FromSnapshot] -> ShowS
$cshowList :: [FromSnapshot] -> ShowS
show :: FromSnapshot -> String
$cshow :: FromSnapshot -> String
showsPrec :: Int -> FromSnapshot -> ShowS
$cshowsPrec :: Int -> FromSnapshot -> ShowS
Show)
data DepPackage = DepPackage
{ DepPackage -> CommonPackage
dpCommon :: !CommonPackage
, DepPackage -> PackageLocation
dpLocation :: !PackageLocation
, DepPackage -> Bool
dpHidden :: !Bool
, DepPackage -> FromSnapshot
dpFromSnapshot :: !FromSnapshot
}
data ProjectPackage = ProjectPackage
{ ProjectPackage -> CommonPackage
ppCommon :: !CommonPackage
, ProjectPackage -> Path Abs File
ppCabalFP :: !(Path Abs File)
, ProjectPackage -> ResolvedPath Dir
ppResolvedDir :: !(ResolvedPath Dir)
}
data GlobalPackage
= GlobalPackage !Version
| ReplacedGlobalPackage ![PackageName]
deriving GlobalPackage -> GlobalPackage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GlobalPackage -> GlobalPackage -> Bool
$c/= :: GlobalPackage -> GlobalPackage -> Bool
== :: GlobalPackage -> GlobalPackage -> Bool
$c== :: GlobalPackage -> GlobalPackage -> Bool
Eq
isReplacedGlobal :: GlobalPackage -> Bool
isReplacedGlobal :: GlobalPackage -> Bool
isReplacedGlobal (ReplacedGlobalPackage [PackageName]
_) = Bool
True
isReplacedGlobal (GlobalPackage Version
_) = Bool
False
data SMWanted = SMWanted
{ SMWanted -> WantedCompiler
smwCompiler :: !WantedCompiler
, SMWanted -> Map PackageName ProjectPackage
smwProject :: !(Map PackageName ProjectPackage)
, SMWanted -> Map PackageName DepPackage
smwDeps :: !(Map PackageName DepPackage)
, SMWanted -> RawSnapshotLocation
smwSnapshotLocation :: !RawSnapshotLocation
}
data SMActual global = SMActual
{ forall global. SMActual global -> ActualCompiler
smaCompiler :: !ActualCompiler
, forall global. SMActual global -> Map PackageName ProjectPackage
smaProject :: !(Map PackageName ProjectPackage)
, forall global. SMActual global -> Map PackageName DepPackage
smaDeps :: !(Map PackageName DepPackage)
, forall global. SMActual global -> Map PackageName global
smaGlobal :: !(Map PackageName global)
}
newtype GlobalPackageVersion = GlobalPackageVersion Version
data Target
= TargetAll !PackageType
| TargetComps !(Set NamedComponent)
data PackageType = PTProject | PTDependency
deriving (PackageType -> PackageType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackageType -> PackageType -> Bool
$c/= :: PackageType -> PackageType -> Bool
== :: PackageType -> PackageType -> Bool
$c== :: PackageType -> PackageType -> Bool
Eq, Int -> PackageType -> ShowS
[PackageType] -> ShowS
PackageType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackageType] -> ShowS
$cshowList :: [PackageType] -> ShowS
show :: PackageType -> String
$cshow :: PackageType -> String
showsPrec :: Int -> PackageType -> ShowS
$cshowsPrec :: Int -> PackageType -> ShowS
Show)
data SMTargets = SMTargets
{ SMTargets -> Map PackageName Target
smtTargets :: !(Map PackageName Target)
, SMTargets -> Map PackageName DepPackage
smtDeps :: !(Map PackageName DepPackage)
}
data SourceMap = SourceMap
{ SourceMap -> SMTargets
smTargets :: !SMTargets
, SourceMap -> ActualCompiler
smCompiler :: !ActualCompiler
, SourceMap -> Map PackageName ProjectPackage
smProject :: !(Map PackageName ProjectPackage)
, SourceMap -> Map PackageName DepPackage
smDeps :: !(Map PackageName DepPackage)
, SourceMap -> Map PackageName GlobalPackage
smGlobal :: !(Map PackageName GlobalPackage)
}
newtype SourceMapHash = SourceMapHash SHA256
smRelDir :: (MonadThrow m) => SourceMapHash -> m (Path Rel Dir)
smRelDir :: forall (m :: * -> *).
MonadThrow m =>
SourceMapHash -> m (Path Rel Dir)
smRelDir (SourceMapHash SHA256
smh) = forall (m :: * -> *). MonadThrow m => String -> m (Path Rel Dir)
parseRelDir forall a b. (a -> b) -> a -> b
$ Text -> String
T.unpack forall a b. (a -> b) -> a -> b
$ SHA256 -> Text
SHA256.toHexText SHA256
smh