{-# LANGUAGE CPP, FlexibleContexts, FlexibleInstances, OverloadedStrings, ScopedTypeVariables, TemplateHaskell #-}
module Debian.Debianize.Finalize
( debianize
, debianizeWith
, debianizeWebsite
, watchAtom
) where
import Control.Lens hiding ((<.>))
import Control.Monad (unless, when)
import Control.Monad as List (mapM_)
import Control.Monad.State (get, modify)
import Control.Monad.Trans (liftIO, MonadIO)
import Data.ByteString.Lazy.UTF8 (fromString)
import Data.Char (isSpace, toLower)
import Data.Digest.Pure.MD5 (md5)
import Data.Function (on)
import Data.List as List (dropWhileEnd, filter, intercalate, map, nub, null, unlines, maximumBy)
import Data.Map as Map (delete, elems, insertWith, lookup, Map, toList)
import Data.Maybe (fromMaybe, isJust, fromJust)
import Data.Set as Set (difference, filter, fold, fromList, insert, map, null, Set, singleton, toList, union, unions)
import Data.Text as Text (intercalate, pack, Text, unlines, unpack)
import Debian.Changes (ChangeLog(..), ChangeLogEntry(..))
import Debian.Codename (parseCodename)
import Debian.Debianize.BasicInfo (cabalFlagAssignments, compilerFlavor, verbosity)
import qualified Debian.Debianize.BinaryDebDescription as B
import Debian.Debianize.BuildDependencies (debianBuildDeps, debianBuildDepsIndep)
import qualified Debian.Debianize.CabalInfo as A
import Debian.Debianize.Changelog (dropFutureEntries)
import qualified Debian.Debianize.DebInfo as D
import Debian.Debianize.DebianName (debianName, debianNameBase)
import Debian.Debianize.ExecAtoms (execAtoms)
import Debian.Debianize.Goodies (expandWebsite, expandServer, expandBackups)
import Debian.Debianize.InputDebian (dataTop, dataDest, inputChangeLog)
import Debian.Debianize.Monad as Monad (CabalT, liftCabal)
import Debian.Debianize.Prelude ((.?=), stripWith)
import qualified Debian.Debianize.SourceDebDescription as S
import Debian.Debianize.VersionSplits (DebBase(DebBase))
import Debian.GHC (compilerPackageName)
import Debian.Orphans ()
import Debian.Policy (getCurrentDebianUser, getDebhelperCompatLevel, haskellMaintainer, maintainerOfLastResort, PackageArchitectures(Any, All), PackagePriority(Optional), parseMaintainer, parseStandardsVersion, Section(..), SourceFormat(Native3))
import Debian.Pretty (PP(..), ppShow)
import Debian.Relation (BinPkgName, BinPkgName(BinPkgName), Relation(Rel), Relations, SrcPkgName(SrcPkgName))
import qualified Debian.Relation as D (BinPkgName(BinPkgName), Relation(..))
import Debian.Time (getCurrentLocalRFC822Time)
import qualified Debian.Version as V (buildDebianVersion, DebianVersion, parseDebianVersion', epoch, version, revision)
import Distribution.Compiler (CompilerFlavor(GHC))
import Distribution.Compiler (CompilerFlavor(GHCJS))
import Distribution.Package (Dependency(..), PackageIdentifier(..), PackageName, unPackageName)
import Distribution.PackageDescription as Cabal (allBuildInfo, author, BuildInfo(buildable, extraLibs), Executable(buildInfo, exeName), FlagName, mkFlagName, unFlagName, maintainer, PackageDescription(testSuites, description))
import Distribution.Types.UnqualComponentName
import Distribution.PackageDescription as Cabal (PackageDescription(dataFiles, executables, library, package, synopsis))
#if MIN_VERSION_Cabal(3,2,0)
import qualified Distribution.Utils.ShortText as ST
#endif
import Prelude hiding (init, log, map, unlines, unlines, writeFile)
import System.Directory (doesFileExist)
import System.FilePath ((<.>), (</>), makeRelative, splitFileName, takeDirectory, takeFileName)
import System.IO (hPutStrLn, stderr)
import Text.Parsec.Rfc2822 (NameAddr(..))
import Distribution.Pretty (Pretty(pretty))
debianize :: (MonadIO m, MonadFail m) => CabalT m () -> CabalT m ()
debianize :: forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m ()
debianize = CabalT m () -> CabalT m () -> CabalT m ()
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m () -> CabalT m ()
debianizeWith (() -> CabalT m ()
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
debianizeWebsite :: (MonadIO m, MonadFail m) => CabalT m () -> CabalT m ()
debianizeWebsite :: forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m ()
debianizeWebsite = CabalT m () -> CabalT m () -> CabalT m ()
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m () -> CabalT m ()
debianizeWith (CabalT m ()
forall (m :: * -> *). Monad m => CabalT m ()
expandWebsite CabalT m () -> CabalT m () -> CabalT m ()
forall a b.
StateT CabalInfo m a
-> StateT CabalInfo m b -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CabalT m ()
forall (m :: * -> *). Monad m => CabalT m ()
expandServer CabalT m () -> CabalT m () -> CabalT m ()
forall a b.
StateT CabalInfo m a
-> StateT CabalInfo m b -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CabalT m ()
forall (m :: * -> *). Monad m => CabalT m ()
expandBackups)
debianizeWith :: (MonadIO m, MonadFail m) => CabalT m () -> CabalT m () -> CabalT m ()
debianizeWith :: forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m () -> CabalT m ()
debianizeWith CabalT m ()
goodies CabalT m ()
customize =
do StateT DebInfo m () -> CabalT m ()
forall (m :: * -> *) a.
Monad m =>
StateT DebInfo m a -> StateT CabalInfo m a
liftCabal StateT DebInfo m ()
forall (m :: * -> *). MonadIO m => DebianT m ()
inputChangeLog
CabalT m ()
customize
CabalT m () -> CabalT m ()
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m ()
finalizeDebianization CabalT m ()
goodies
finalizeDebianization :: (MonadIO m, MonadFail m) => CabalT m () -> CabalT m ()
finalizeDebianization :: forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m ()
finalizeDebianization CabalT m ()
goodies =
do [Char]
date <- IO [Char] -> StateT CabalInfo m [Char]
forall a. IO a -> StateT CabalInfo m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO [Char]
getCurrentLocalRFC822Time
Maybe NameAddr
currentUser <- IO (Maybe NameAddr) -> StateT CabalInfo m (Maybe NameAddr)
forall a. IO a -> StateT CabalInfo m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO (Maybe NameAddr)
getCurrentDebianUser
Maybe Int
debhelperCompat <- IO (Maybe Int) -> StateT CabalInfo m (Maybe Int)
forall a. IO a -> StateT CabalInfo m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO (Maybe Int)
getDebhelperCompatLevel
Bool
setupExists <- [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or ([Bool] -> Bool)
-> StateT CabalInfo m [Bool] -> StateT CabalInfo m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Char] -> StateT CabalInfo m Bool)
-> [[Char]] -> StateT CabalInfo m [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (IO Bool -> StateT CabalInfo m Bool
forall a. IO a -> StateT CabalInfo m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> StateT CabalInfo m Bool)
-> ([Char] -> IO Bool) -> [Char] -> StateT CabalInfo m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> IO Bool
doesFileExist) [[Char]
"Setup.hs", [Char]
"Setup.lhs"]
CabalT m ()
-> [Char] -> Maybe NameAddr -> Maybe Int -> Bool -> CabalT m ()
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m ()
-> [Char] -> Maybe NameAddr -> Maybe Int -> Bool -> CabalT m ()
finalizeDebianization' CabalT m ()
goodies [Char]
date Maybe NameAddr
currentUser Maybe Int
debhelperCompat Bool
setupExists
Int
vb <- Getting Int CabalInfo Int -> StateT CabalInfo m Int
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const Int DebInfo) -> CabalInfo -> Const Int CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const Int DebInfo)
-> CabalInfo -> Const Int CabalInfo)
-> ((Int -> Const Int Int) -> DebInfo -> Const Int DebInfo)
-> Getting Int CabalInfo Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Flags -> Const Int Flags) -> DebInfo -> Const Int DebInfo
Lens' DebInfo Flags
D.flags ((Flags -> Const Int Flags) -> DebInfo -> Const Int DebInfo)
-> ((Int -> Const Int Int) -> Flags -> Const Int Flags)
-> (Int -> Const Int Int)
-> DebInfo
-> Const Int DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Const Int Int) -> Flags -> Const Int Flags
Lens' Flags Int
verbosity)
Bool -> CabalT m () -> CabalT m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
vb Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
3) (StateT CabalInfo m CabalInfo
forall s (m :: * -> *). MonadState s m => m s
get StateT CabalInfo m CabalInfo
-> (CabalInfo -> CabalT m ()) -> CabalT m ()
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ CabalInfo
x -> IO () -> CabalT m ()
forall a. IO a -> StateT CabalInfo m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO ([Char] -> IO ()
putStrLn ([Char]
"\nFinalized Cabal Info: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ CabalInfo -> [Char]
forall a. Show a => a -> [Char]
show CabalInfo
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\n")))
([Char] -> CabalT m ())
-> (NameAddr -> CabalT m ())
-> Either [Char] NameAddr
-> CabalT m ()
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
e -> IO () -> CabalT m ()
forall a. IO a -> StateT CabalInfo m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> CabalT m ()) -> IO () -> CabalT m ()
forall a b. (a -> b) -> a -> b
$ Handle -> [Char] -> IO ()
hPutStrLn Handle
stderr ([Char]
"WARNING: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
e)) (\NameAddr
_ -> () -> CabalT m ()
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()) (Either [Char] NameAddr -> CabalT m ())
-> StateT CabalInfo m (Either [Char] NameAddr) -> CabalT m ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Getting (Either [Char] NameAddr) CabalInfo (Either [Char] NameAddr)
-> StateT CabalInfo m (Either [Char] NameAddr)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Either [Char] NameAddr) DebInfo)
-> CabalInfo -> Const (Either [Char] NameAddr) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Either [Char] NameAddr) DebInfo)
-> CabalInfo -> Const (Either [Char] NameAddr) CabalInfo)
-> ((Either [Char] NameAddr
-> Const (Either [Char] NameAddr) (Either [Char] NameAddr))
-> DebInfo -> Const (Either [Char] NameAddr) DebInfo)
-> Getting
(Either [Char] NameAddr) CabalInfo (Either [Char] NameAddr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription
-> Const (Either [Char] NameAddr) SourceDebDescription)
-> DebInfo -> Const (Either [Char] NameAddr) DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription
-> Const (Either [Char] NameAddr) SourceDebDescription)
-> DebInfo -> Const (Either [Char] NameAddr) DebInfo)
-> ((Either [Char] NameAddr
-> Const (Either [Char] NameAddr) (Either [Char] NameAddr))
-> SourceDebDescription
-> Const (Either [Char] NameAddr) SourceDebDescription)
-> (Either [Char] NameAddr
-> Const (Either [Char] NameAddr) (Either [Char] NameAddr))
-> DebInfo
-> Const (Either [Char] NameAddr) DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either [Char] NameAddr
-> Const (Either [Char] NameAddr) (Either [Char] NameAddr))
-> SourceDebDescription
-> Const (Either [Char] NameAddr) SourceDebDescription
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer)
finalizeDebianization' ::
(MonadIO m, MonadFail m)
=> CabalT m ()
-> String
-> Maybe NameAddr
-> Maybe Int
-> Bool
-> CabalT m ()
finalizeDebianization' :: forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m ()
-> [Char] -> Maybe NameAddr -> Maybe Int -> Bool -> CabalT m ()
finalizeDebianization' CabalT m ()
goodies [Char]
date Maybe NameAddr
currentUser Maybe Int
debhelperCompat Bool
setupExists =
do
CompilerFlavor
hc <- Getting CompilerFlavor CabalInfo CompilerFlavor
-> StateT CabalInfo m CompilerFlavor
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const CompilerFlavor DebInfo)
-> CabalInfo -> Const CompilerFlavor CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const CompilerFlavor DebInfo)
-> CabalInfo -> Const CompilerFlavor CabalInfo)
-> ((CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> DebInfo -> Const CompilerFlavor DebInfo)
-> Getting CompilerFlavor CabalInfo CompilerFlavor
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Flags -> Const CompilerFlavor Flags)
-> DebInfo -> Const CompilerFlavor DebInfo
Lens' DebInfo Flags
D.flags ((Flags -> Const CompilerFlavor Flags)
-> DebInfo -> Const CompilerFlavor DebInfo)
-> ((CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> Flags -> Const CompilerFlavor Flags)
-> (CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> DebInfo
-> Const CompilerFlavor DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> Flags -> Const CompilerFlavor Flags
Lens' Flags CompilerFlavor
compilerFlavor)
PackageDescription
pkgDesc <- Getting PackageDescription CabalInfo PackageDescription
-> StateT CabalInfo m PackageDescription
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting PackageDescription CabalInfo PackageDescription
Lens' CabalInfo PackageDescription
A.packageDescription
TestsStatus
testsStatus <- Getting TestsStatus CabalInfo TestsStatus
-> StateT CabalInfo m TestsStatus
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const TestsStatus DebInfo)
-> CabalInfo -> Const TestsStatus CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const TestsStatus DebInfo)
-> CabalInfo -> Const TestsStatus CabalInfo)
-> ((TestsStatus -> Const TestsStatus TestsStatus)
-> DebInfo -> Const TestsStatus DebInfo)
-> Getting TestsStatus CabalInfo TestsStatus
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TestsStatus -> Const TestsStatus TestsStatus)
-> DebInfo -> Const TestsStatus DebInfo
Lens' DebInfo TestsStatus
D.testsStatus)
let testsExist :: Bool
testsExist = Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ [TestSuite] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null ([TestSuite] -> Bool) -> [TestSuite] -> Bool
forall a b. (a -> b) -> a -> b
$ PackageDescription -> [TestSuite]
Cabal.testSuites PackageDescription
pkgDesc
case (Bool
testsExist, TestsStatus
testsStatus) of
(Bool
True, TestsStatus
D.TestsRun) -> ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> (([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo)
-> ([Text] -> Identity [Text])
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo
Lens' DebInfo [Text]
D.rulesSettings) (([Text] -> Identity [Text]) -> CabalInfo -> Identity CabalInfo)
-> ([Text] -> [Text]) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text
"DEB_ENABLE_TESTS = yes"])
(Bool
True, TestsStatus
D.TestsBuild) -> ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> (([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo)
-> ([Text] -> Identity [Text])
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo
Lens' DebInfo [Text]
D.rulesSettings) (([Text] -> Identity [Text]) -> CabalInfo -> Identity CabalInfo)
-> ([Text] -> [Text]) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text
"DEB_ENABLE_TESTS = yes", Text
"DEB_BUILD_OPTIONS += nocheck"])
(Bool, TestsStatus)
_ -> () -> CabalT m ()
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> (([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo)
-> ([Text] -> Identity [Text])
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo
Lens' DebInfo [Text]
D.rulesSettings) (([Text] -> Identity [Text]) -> CabalInfo -> Identity CabalInfo)
-> ([Text] -> [Text]) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%=
([Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text
"DEB_SETUP_BIN_NAME = " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> if Bool
setupExists then Text
"debian/hlibrary.setup" else Text
"cabal"])
PackageType -> CabalT m ()
forall (m :: * -> *). Monad m => PackageType -> CabalT m ()
finalizeSourceName PackageType
B.HaskellSource
CompilerFlavor -> CabalT m ()
forall (m :: * -> *). Monad m => CompilerFlavor -> CabalT m ()
checkOfficialSettings CompilerFlavor
hc
CompilerFlavor -> CabalT m ()
forall (m :: * -> *). Monad m => CompilerFlavor -> CabalT m ()
addExtraLibDependencies CompilerFlavor
hc
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe Text -> f (Maybe Text)) -> DebInfo -> f DebInfo)
-> (Maybe Text -> f (Maybe Text))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Text -> f (Maybe Text)) -> DebInfo -> f DebInfo
Lens' DebInfo (Maybe Text)
D.watch) (forall {f :: * -> *}.
Functor f =>
(Maybe Text -> f (Maybe Text)) -> CabalInfo -> f CabalInfo)
-> Maybe Text -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Text -> Maybe Text
forall a. a -> Maybe a
Just (PackageName -> Text
watchAtom (PackageIdentifier -> PackageName
pkgName (PackageIdentifier -> PackageName)
-> PackageIdentifier -> PackageName
forall a b. (a -> b) -> a -> b
$ PackageDescription -> PackageIdentifier
Cabal.package (PackageDescription -> PackageIdentifier)
-> PackageDescription -> PackageIdentifier
forall a b. (a -> b) -> a -> b
$ PackageDescription
pkgDesc))
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe Section -> f (Maybe Section)) -> DebInfo -> f DebInfo)
-> (Maybe Section -> f (Maybe Section))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> f SourceDebDescription)
-> DebInfo -> f DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> f SourceDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe Section -> f (Maybe Section))
-> SourceDebDescription -> f SourceDebDescription)
-> (Maybe Section -> f (Maybe Section))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Section -> f (Maybe Section))
-> SourceDebDescription -> f SourceDebDescription
Lens' SourceDebDescription (Maybe Section)
S.section) (forall {f :: * -> *}.
Functor f =>
(Maybe Section -> f (Maybe Section)) -> CabalInfo -> f CabalInfo)
-> Maybe Section -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Section -> Maybe Section
forall a. a -> Maybe a
Just ([Char] -> Section
MainSection [Char]
"haskell")
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe PackagePriority -> f (Maybe PackagePriority))
-> DebInfo -> f DebInfo)
-> (Maybe PackagePriority -> f (Maybe PackagePriority))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> f SourceDebDescription)
-> DebInfo -> f DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> f SourceDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe PackagePriority -> f (Maybe PackagePriority))
-> SourceDebDescription -> f SourceDebDescription)
-> (Maybe PackagePriority -> f (Maybe PackagePriority))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe PackagePriority -> f (Maybe PackagePriority))
-> SourceDebDescription -> f SourceDebDescription
Lens' SourceDebDescription (Maybe PackagePriority)
S.priority) (forall {f :: * -> *}.
Functor f =>
(Maybe PackagePriority -> f (Maybe PackagePriority))
-> CabalInfo -> f CabalInfo)
-> Maybe PackagePriority -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= PackagePriority -> Maybe PackagePriority
forall a. a -> Maybe a
Just PackagePriority
Optional
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe Int -> f (Maybe Int)) -> DebInfo -> f DebInfo)
-> (Maybe Int -> f (Maybe Int))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Int -> f (Maybe Int)) -> DebInfo -> f DebInfo
Lens' DebInfo (Maybe Int)
D.compat) (forall {f :: * -> *}.
Functor f =>
(Maybe Int -> f (Maybe Int)) -> CabalInfo -> f CabalInfo)
-> Maybe Int -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Maybe Int
debhelperCompat
[Char] -> Maybe NameAddr -> CabalT m ()
forall (m :: * -> *).
Monad m =>
[Char] -> Maybe NameAddr -> CabalT m ()
finalizeChangelog [Char]
date Maybe NameAddr
currentUser
Maybe NameAddr -> CabalT m ()
forall (m :: * -> *). MonadFail m => Maybe NameAddr -> CabalT m ()
finalizeControl Maybe NameAddr
currentUser
CabalT m ()
forall (m :: * -> *). MonadIO m => CabalT m ()
finalizeRules
CabalT m () -> CabalT m ()
forall (m :: * -> *). Monad m => CabalT m () -> CabalT m ()
expandAtoms CabalT m ()
goodies
Getting
(Map BinPkgName InstallFile) CabalInfo (Map BinPkgName InstallFile)
-> StateT CabalInfo m (Map BinPkgName InstallFile)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Map BinPkgName InstallFile) DebInfo)
-> CabalInfo -> Const (Map BinPkgName InstallFile) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Map BinPkgName InstallFile) DebInfo)
-> CabalInfo -> Const (Map BinPkgName InstallFile) CabalInfo)
-> ((Map BinPkgName InstallFile
-> Const (Map BinPkgName InstallFile) (Map BinPkgName InstallFile))
-> DebInfo -> Const (Map BinPkgName InstallFile) DebInfo)
-> Getting
(Map BinPkgName InstallFile) CabalInfo (Map BinPkgName InstallFile)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map BinPkgName InstallFile
-> Const (Map BinPkgName InstallFile) (Map BinPkgName InstallFile))
-> DebInfo -> Const (Map BinPkgName InstallFile) DebInfo
Lens' DebInfo (Map BinPkgName InstallFile)
D.executable) StateT CabalInfo m (Map BinPkgName InstallFile)
-> (Map BinPkgName InstallFile -> CabalT m ()) -> CabalT m ()
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ((BinPkgName, InstallFile) -> CabalT m ())
-> [(BinPkgName, InstallFile)] -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ (BinPkgName -> CabalT m ()
forall (m :: * -> *). Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage (BinPkgName -> CabalT m ())
-> ((BinPkgName, InstallFile) -> BinPkgName)
-> (BinPkgName, InstallFile)
-> CabalT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (BinPkgName, InstallFile) -> BinPkgName
forall a b. (a, b) -> a
fst) ([(BinPkgName, InstallFile)] -> CabalT m ())
-> (Map BinPkgName InstallFile -> [(BinPkgName, InstallFile)])
-> Map BinPkgName InstallFile
-> CabalT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map BinPkgName InstallFile -> [(BinPkgName, InstallFile)]
forall k a. Map k a -> [(k, a)]
Map.toList
Getting (Map BinPkgName [Char]) CabalInfo (Map BinPkgName [Char])
-> StateT CabalInfo m (Map BinPkgName [Char])
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Map BinPkgName [Char]) DebInfo)
-> CabalInfo -> Const (Map BinPkgName [Char]) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Map BinPkgName [Char]) DebInfo)
-> CabalInfo -> Const (Map BinPkgName [Char]) CabalInfo)
-> ((Map BinPkgName [Char]
-> Const (Map BinPkgName [Char]) (Map BinPkgName [Char]))
-> DebInfo -> Const (Map BinPkgName [Char]) DebInfo)
-> Getting
(Map BinPkgName [Char]) CabalInfo (Map BinPkgName [Char])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map BinPkgName [Char]
-> Const (Map BinPkgName [Char]) (Map BinPkgName [Char]))
-> DebInfo -> Const (Map BinPkgName [Char]) DebInfo
Lens' DebInfo (Map BinPkgName [Char])
D.backups) StateT CabalInfo m (Map BinPkgName [Char])
-> (Map BinPkgName [Char] -> CabalT m ()) -> CabalT m ()
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ((BinPkgName, [Char]) -> CabalT m ())
-> [(BinPkgName, [Char])] -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ (BinPkgName -> CabalT m ()
forall (m :: * -> *). Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage (BinPkgName -> CabalT m ())
-> ((BinPkgName, [Char]) -> BinPkgName)
-> (BinPkgName, [Char])
-> CabalT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (BinPkgName, [Char]) -> BinPkgName
forall a b. (a, b) -> a
fst) ([(BinPkgName, [Char])] -> CabalT m ())
-> (Map BinPkgName [Char] -> [(BinPkgName, [Char])])
-> Map BinPkgName [Char]
-> CabalT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map BinPkgName [Char] -> [(BinPkgName, [Char])]
forall k a. Map k a -> [(k, a)]
Map.toList
Getting (Map BinPkgName Server) CabalInfo (Map BinPkgName Server)
-> StateT CabalInfo m (Map BinPkgName Server)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Map BinPkgName Server) DebInfo)
-> CabalInfo -> Const (Map BinPkgName Server) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Map BinPkgName Server) DebInfo)
-> CabalInfo -> Const (Map BinPkgName Server) CabalInfo)
-> ((Map BinPkgName Server
-> Const (Map BinPkgName Server) (Map BinPkgName Server))
-> DebInfo -> Const (Map BinPkgName Server) DebInfo)
-> Getting
(Map BinPkgName Server) CabalInfo (Map BinPkgName Server)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map BinPkgName Server
-> Const (Map BinPkgName Server) (Map BinPkgName Server))
-> DebInfo -> Const (Map BinPkgName Server) DebInfo
Lens' DebInfo (Map BinPkgName Server)
D.serverInfo) StateT CabalInfo m (Map BinPkgName Server)
-> (Map BinPkgName Server -> CabalT m ()) -> CabalT m ()
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ((BinPkgName, Server) -> CabalT m ())
-> [(BinPkgName, Server)] -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ (BinPkgName -> CabalT m ()
forall (m :: * -> *). Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage (BinPkgName -> CabalT m ())
-> ((BinPkgName, Server) -> BinPkgName)
-> (BinPkgName, Server)
-> CabalT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (BinPkgName, Server) -> BinPkgName
forall a b. (a, b) -> a
fst) ([(BinPkgName, Server)] -> CabalT m ())
-> (Map BinPkgName Server -> [(BinPkgName, Server)])
-> Map BinPkgName Server
-> CabalT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map BinPkgName Server -> [(BinPkgName, Server)]
forall k a. Map k a -> [(k, a)]
Map.toList
Getting (Map BinPkgName Site) CabalInfo (Map BinPkgName Site)
-> StateT CabalInfo m (Map BinPkgName Site)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Map BinPkgName Site) DebInfo)
-> CabalInfo -> Const (Map BinPkgName Site) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Map BinPkgName Site) DebInfo)
-> CabalInfo -> Const (Map BinPkgName Site) CabalInfo)
-> ((Map BinPkgName Site
-> Const (Map BinPkgName Site) (Map BinPkgName Site))
-> DebInfo -> Const (Map BinPkgName Site) DebInfo)
-> Getting (Map BinPkgName Site) CabalInfo (Map BinPkgName Site)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map BinPkgName Site
-> Const (Map BinPkgName Site) (Map BinPkgName Site))
-> DebInfo -> Const (Map BinPkgName Site) DebInfo
Lens' DebInfo (Map BinPkgName Site)
D.website) StateT CabalInfo m (Map BinPkgName Site)
-> (Map BinPkgName Site -> CabalT m ()) -> CabalT m ()
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ((BinPkgName, Site) -> CabalT m ())
-> [(BinPkgName, Site)] -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ (BinPkgName -> CabalT m ()
forall (m :: * -> *). Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage (BinPkgName -> CabalT m ())
-> ((BinPkgName, Site) -> BinPkgName)
-> (BinPkgName, Site)
-> CabalT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (BinPkgName, Site) -> BinPkgName
forall a b. (a, b) -> a
fst) ([(BinPkgName, Site)] -> CabalT m ())
-> (Map BinPkgName Site -> [(BinPkgName, Site)])
-> Map BinPkgName Site
-> CabalT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map BinPkgName Site -> [(BinPkgName, Site)]
forall k a. Map k a -> [(k, a)]
Map.toList
PackageDescription -> CompilerFlavor -> CabalT m ()
forall (m :: * -> *).
Monad m =>
PackageDescription -> CompilerFlavor -> CabalT m ()
librarySpecs PackageDescription
pkgDesc CompilerFlavor
hc
PackageDescription -> CompilerFlavor -> CabalT m ()
forall (m :: * -> *).
Monad m =>
PackageDescription -> CompilerFlavor -> CabalT m ()
makeUtilsPackage PackageDescription
pkgDesc CompilerFlavor
hc
[BinPkgName]
debs <- Getting [BinaryDebDescription] CabalInfo [BinaryDebDescription]
-> StateT CabalInfo m [BinaryDebDescription]
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const [BinaryDebDescription] DebInfo)
-> CabalInfo -> Const [BinaryDebDescription] CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const [BinaryDebDescription] DebInfo)
-> CabalInfo -> Const [BinaryDebDescription] CabalInfo)
-> (([BinaryDebDescription]
-> Const [BinaryDebDescription] [BinaryDebDescription])
-> DebInfo -> Const [BinaryDebDescription] DebInfo)
-> Getting [BinaryDebDescription] CabalInfo [BinaryDebDescription]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription
-> Const [BinaryDebDescription] SourceDebDescription)
-> DebInfo -> Const [BinaryDebDescription] DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription
-> Const [BinaryDebDescription] SourceDebDescription)
-> DebInfo -> Const [BinaryDebDescription] DebInfo)
-> (([BinaryDebDescription]
-> Const [BinaryDebDescription] [BinaryDebDescription])
-> SourceDebDescription
-> Const [BinaryDebDescription] SourceDebDescription)
-> ([BinaryDebDescription]
-> Const [BinaryDebDescription] [BinaryDebDescription])
-> DebInfo
-> Const [BinaryDebDescription] DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([BinaryDebDescription]
-> Const [BinaryDebDescription] [BinaryDebDescription])
-> SourceDebDescription
-> Const [BinaryDebDescription] SourceDebDescription
Lens' SourceDebDescription [BinaryDebDescription]
S.binaryPackages) StateT CabalInfo m [BinaryDebDescription]
-> ([BinaryDebDescription] -> StateT CabalInfo m [BinPkgName])
-> StateT CabalInfo m [BinPkgName]
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [BinPkgName] -> StateT CabalInfo m [BinPkgName]
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([BinPkgName] -> StateT CabalInfo m [BinPkgName])
-> ([BinaryDebDescription] -> [BinPkgName])
-> [BinaryDebDescription]
-> StateT CabalInfo m [BinPkgName]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (BinaryDebDescription -> BinPkgName)
-> [BinaryDebDescription] -> [BinPkgName]
forall a b. (a -> b) -> [a] -> [b]
List.map (Getting BinPkgName BinaryDebDescription BinPkgName
-> BinaryDebDescription -> BinPkgName
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting BinPkgName BinaryDebDescription BinPkgName
Lens' BinaryDebDescription BinPkgName
B.package)
Bool
allowSelfDeps <- Getting Bool CabalInfo Bool -> StateT CabalInfo m Bool
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const Bool DebInfo)
-> CabalInfo -> Const Bool CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const Bool DebInfo)
-> CabalInfo -> Const Bool CabalInfo)
-> ((Bool -> Const Bool Bool) -> DebInfo -> Const Bool DebInfo)
-> Getting Bool CabalInfo Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Bool -> Const Bool Bool) -> DebInfo -> Const Bool DebInfo
Lens' DebInfo Bool
D.allowDebianSelfBuildDeps)
(Relations -> Relations) -> PackageDescription -> CabalT m ()
forall (m :: * -> *).
MonadIO m =>
(Relations -> Relations) -> PackageDescription -> CabalT m ()
putBuildDeps (if Bool
allowSelfDeps then Relations -> Relations
forall a. a -> a
id else [BinPkgName] -> Relations -> Relations
filterRelations [BinPkgName]
debs) PackageDescription
pkgDesc
CabalT m () -> CabalT m ()
forall (m :: * -> *). Monad m => CabalT m () -> CabalT m ()
expandAtoms CabalT m ()
goodies
watchAtom :: PackageName -> Text
watchAtom :: PackageName -> Text
watchAtom PackageName
pkgname =
[Char] -> Text
pack ([Char] -> Text) -> [Char] -> Text
forall a b. (a -> b) -> a -> b
$ [Char]
"version=4\nhttps://hackage.haskell.org/package/" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ PackageName -> [Char]
unPackageName PackageName
pkgname [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"/distro-monitor .*-([0-9\\.]+)\\.(?:zip|tgz|tbz|txz|(?:tar\\.(?:gz|bz2|xz)))\n"
debianVersion :: (Monad m) => CabalT m V.DebianVersion
debianVersion :: forall (m :: * -> *). Monad m => CabalT m DebianVersion
debianVersion =
do PackageName
cabalName <- (PackageIdentifier -> PackageName
pkgName (PackageIdentifier -> PackageName)
-> (PackageDescription -> PackageIdentifier)
-> PackageDescription
-> PackageName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageDescription -> PackageIdentifier
Cabal.package) (PackageDescription -> PackageName)
-> StateT CabalInfo m PackageDescription
-> StateT CabalInfo m PackageName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Getting PackageDescription CabalInfo PackageDescription
-> StateT CabalInfo m PackageDescription
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting PackageDescription CabalInfo PackageDescription
Lens' CabalInfo PackageDescription
A.packageDescription
(DebianVersion
cabalVersion :: V.DebianVersion) <- ([Char] -> DebianVersion
forall string. ParseDebianVersion string => string -> DebianVersion
V.parseDebianVersion' ([Char] -> DebianVersion)
-> (PackageDescription -> [Char])
-> PackageDescription
-> DebianVersion
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Version -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow (Version -> [Char])
-> (PackageDescription -> Version) -> PackageDescription -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageIdentifier -> Version
pkgVersion (PackageIdentifier -> Version)
-> (PackageDescription -> PackageIdentifier)
-> PackageDescription
-> Version
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageDescription -> PackageIdentifier
Cabal.package) (PackageDescription -> DebianVersion)
-> StateT CabalInfo m PackageDescription -> CabalT m DebianVersion
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Getting PackageDescription CabalInfo PackageDescription
-> StateT CabalInfo m PackageDescription
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting PackageDescription CabalInfo PackageDescription
Lens' CabalInfo PackageDescription
A.packageDescription
Maybe Int
cabalEpoch <- PackageName -> CabalT m (Maybe Int)
forall (m :: * -> *).
Monad m =>
PackageName -> CabalT m (Maybe Int)
debianEpoch PackageName
cabalName
SourceFormat
fmt <- Getting SourceFormat CabalInfo SourceFormat
-> StateT CabalInfo m SourceFormat
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const SourceFormat DebInfo)
-> CabalInfo -> Const SourceFormat CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const SourceFormat DebInfo)
-> CabalInfo -> Const SourceFormat CabalInfo)
-> ((SourceFormat -> Const SourceFormat SourceFormat)
-> DebInfo -> Const SourceFormat DebInfo)
-> Getting SourceFormat CabalInfo SourceFormat
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceFormat -> Const SourceFormat SourceFormat)
-> DebInfo -> Const SourceFormat DebInfo
Lens' DebInfo SourceFormat
D.sourceFormat)
Maybe [Char]
cabalRevision <-
do Maybe [Char]
x <- Getting (Maybe [Char]) CabalInfo (Maybe [Char])
-> StateT CabalInfo m (Maybe [Char])
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe [Char]) DebInfo)
-> CabalInfo -> Const (Maybe [Char]) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe [Char]) DebInfo)
-> CabalInfo -> Const (Maybe [Char]) CabalInfo)
-> ((Maybe [Char] -> Const (Maybe [Char]) (Maybe [Char]))
-> DebInfo -> Const (Maybe [Char]) DebInfo)
-> Getting (Maybe [Char]) CabalInfo (Maybe [Char])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe [Char] -> Const (Maybe [Char]) (Maybe [Char]))
-> DebInfo -> Const (Maybe [Char]) DebInfo
Lens' DebInfo (Maybe [Char])
D.revision)
let y :: Maybe [Char]
y = case Maybe [Char]
x of
Maybe [Char]
Nothing -> Maybe [Char]
forall a. Maybe a
Nothing
Just [Char]
"" -> Maybe [Char]
forall a. Maybe a
Nothing
Just [Char]
"-" -> Maybe [Char]
forall a. Maybe a
Nothing
Just (Char
'-':[Char]
r) -> [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
r
Just [Char]
_ -> [Char] -> Maybe [Char]
forall a. HasCallStack => [Char] -> a
error [Char]
"The --revision argument must start with a dash"
Maybe [Char] -> StateT CabalInfo m (Maybe [Char])
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe [Char] -> StateT CabalInfo m (Maybe [Char]))
-> Maybe [Char] -> StateT CabalInfo m (Maybe [Char])
forall a b. (a -> b) -> a -> b
$ case SourceFormat
fmt of
SourceFormat
Native3 -> Maybe [Char]
y
SourceFormat
_ -> Maybe [Char]
-> ([Char] -> Maybe [Char]) -> Maybe [Char] -> Maybe [Char]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
"1") ([Char] -> Maybe [Char]
forall a. a -> Maybe a
Just ([Char] -> Maybe [Char])
-> ([Char] -> [Char]) -> [Char] -> Maybe [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> [Char]
forall a. Ord a => a -> a -> a
max [Char]
"1") Maybe [Char]
y
Maybe DebianVersion
versionArg <- Getting (Maybe DebianVersion) CabalInfo (Maybe DebianVersion)
-> StateT CabalInfo m (Maybe DebianVersion)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe DebianVersion) DebInfo)
-> CabalInfo -> Const (Maybe DebianVersion) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe DebianVersion) DebInfo)
-> CabalInfo -> Const (Maybe DebianVersion) CabalInfo)
-> ((Maybe DebianVersion
-> Const (Maybe DebianVersion) (Maybe DebianVersion))
-> DebInfo -> Const (Maybe DebianVersion) DebInfo)
-> Getting (Maybe DebianVersion) CabalInfo (Maybe DebianVersion)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe DebianVersion
-> Const (Maybe DebianVersion) (Maybe DebianVersion))
-> DebInfo -> Const (Maybe DebianVersion) DebInfo
Lens' DebInfo (Maybe DebianVersion)
D.debVersion)
(Maybe DebianVersion
debVersion :: Maybe V.DebianVersion) <- Getting (Maybe ChangeLog) CabalInfo (Maybe ChangeLog)
-> StateT CabalInfo m (Maybe ChangeLog)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe ChangeLog) DebInfo)
-> CabalInfo -> Const (Maybe ChangeLog) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe ChangeLog) DebInfo)
-> CabalInfo -> Const (Maybe ChangeLog) CabalInfo)
-> ((Maybe ChangeLog -> Const (Maybe ChangeLog) (Maybe ChangeLog))
-> DebInfo -> Const (Maybe ChangeLog) DebInfo)
-> Getting (Maybe ChangeLog) CabalInfo (Maybe ChangeLog)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe ChangeLog -> Const (Maybe ChangeLog) (Maybe ChangeLog))
-> DebInfo -> Const (Maybe ChangeLog) DebInfo
Lens' DebInfo (Maybe ChangeLog)
D.changelog) StateT CabalInfo m (Maybe ChangeLog)
-> (Maybe ChangeLog -> StateT CabalInfo m (Maybe DebianVersion))
-> StateT CabalInfo m (Maybe DebianVersion)
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Maybe DebianVersion -> StateT CabalInfo m (Maybe DebianVersion)
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe DebianVersion -> StateT CabalInfo m (Maybe DebianVersion))
-> (Maybe ChangeLog -> Maybe DebianVersion)
-> Maybe ChangeLog
-> StateT CabalInfo m (Maybe DebianVersion)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe DebianVersion
-> (ChangeLog -> Maybe DebianVersion)
-> Maybe ChangeLog
-> Maybe DebianVersion
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Maybe DebianVersion
forall a. Maybe a
Nothing ChangeLog -> Maybe DebianVersion
changelogVersion
case () of
()
_ | Bool -> (DebianVersion -> Bool) -> Maybe DebianVersion -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False (\ DebianVersion
v -> DebianVersion
v DebianVersion -> DebianVersion -> Bool
forall a. Ord a => a -> a -> Bool
< Maybe Int -> [Char] -> Maybe [Char] -> DebianVersion
V.buildDebianVersion Maybe Int
cabalEpoch (DebianVersion -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow DebianVersion
cabalVersion) Maybe [Char]
forall a. Maybe a
Nothing) Maybe DebianVersion
versionArg ->
[Char] -> CabalT m DebianVersion
forall a. HasCallStack => [Char] -> a
error ([Char]
"Version from --deb-version (" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Maybe DebianVersion -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow Maybe DebianVersion
versionArg [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
[Char]
") is older than cabal version (" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ DebianVersion -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow DebianVersion
cabalVersion [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
[Char]
"), maybe you need to unpin this package?")
()
_ | Maybe DebianVersion -> Bool
forall a. Maybe a -> Bool
isJust Maybe DebianVersion
versionArg -> DebianVersion -> CabalT m DebianVersion
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (DebianVersion -> CabalT m DebianVersion)
-> DebianVersion -> CabalT m DebianVersion
forall a b. (a -> b) -> a -> b
$ Maybe DebianVersion -> DebianVersion
forall a. HasCallStack => Maybe a -> a
fromJust Maybe DebianVersion
versionArg
()
_ | Maybe DebianVersion -> Bool
forall a. Maybe a -> Bool
isJust Maybe DebianVersion
debVersion ->
case (DebianVersion -> Maybe Int
V.epoch (Maybe DebianVersion -> DebianVersion
forall a. HasCallStack => Maybe a -> a
fromJust Maybe DebianVersion
debVersion),
[Char] -> DebianVersion
forall string. ParseDebianVersion string => string -> DebianVersion
V.parseDebianVersion' (DebianVersion -> [Char]
V.version (Maybe DebianVersion -> DebianVersion
forall a. HasCallStack => Maybe a -> a
fromJust Maybe DebianVersion
debVersion)),
DebianVersion -> Maybe [Char]
V.revision (Maybe DebianVersion -> DebianVersion
forall a. HasCallStack => Maybe a -> a
fromJust Maybe DebianVersion
debVersion)) of
(Maybe Int
debEpoch, DebianVersion
debianVersion', (Maybe [Char]
debianRevision :: Maybe String)) ->
let finalEpoch :: Maybe Int
finalEpoch = Maybe Int -> Maybe Int -> Maybe Int
forall a. Ord a => a -> a -> a
max Maybe Int
debEpoch Maybe Int
cabalEpoch
finalVersion :: DebianVersion
finalVersion = DebianVersion -> DebianVersion -> DebianVersion
forall a. Ord a => a -> a -> a
max DebianVersion
debianVersion' DebianVersion
cabalVersion
(Maybe [Char]
finalRevision :: Maybe String) = (Maybe [Char] -> Maybe [Char] -> Ordering)
-> [Maybe [Char]] -> Maybe [Char]
forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
maximumBy (Maybe DebianVersion -> Maybe DebianVersion -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Maybe DebianVersion -> Maybe DebianVersion -> Ordering)
-> (Maybe [Char] -> Maybe DebianVersion)
-> Maybe [Char]
-> Maybe [Char]
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` ([Char] -> DebianVersion) -> Maybe [Char] -> Maybe DebianVersion
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Char] -> DebianVersion
forall string. ParseDebianVersion string => string -> DebianVersion
V.parseDebianVersion') [Maybe [Char]
debianRevision, Maybe [Char]
cabalRevision] in
DebianVersion -> CabalT m DebianVersion
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (DebianVersion -> CabalT m DebianVersion)
-> DebianVersion -> CabalT m DebianVersion
forall a b. (a -> b) -> a -> b
$ Maybe Int -> [Char] -> Maybe [Char] -> DebianVersion
V.buildDebianVersion Maybe Int
finalEpoch (DebianVersion -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow DebianVersion
finalVersion) Maybe [Char]
finalRevision
()
_ -> DebianVersion -> CabalT m DebianVersion
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (DebianVersion -> CabalT m DebianVersion)
-> DebianVersion -> CabalT m DebianVersion
forall a b. (a -> b) -> a -> b
$ Maybe Int -> [Char] -> Maybe [Char] -> DebianVersion
V.buildDebianVersion Maybe Int
cabalEpoch (DebianVersion -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow DebianVersion
cabalVersion) Maybe [Char]
cabalRevision
changelogVersion :: ChangeLog -> Maybe V.DebianVersion
changelogVersion :: ChangeLog -> Maybe DebianVersion
changelogVersion (ChangeLog (Entry {logVersion :: ChangeLogEntry -> DebianVersion
logVersion = DebianVersion
x} : [ChangeLogEntry]
_)) = DebianVersion -> Maybe DebianVersion
forall a. a -> Maybe a
Just DebianVersion
x
changelogVersion ChangeLog
_ = Maybe DebianVersion
forall a. Maybe a
Nothing
debianEpoch :: Monad m => PackageName -> CabalT m (Maybe Int)
debianEpoch :: forall (m :: * -> *).
Monad m =>
PackageName -> CabalT m (Maybe Int)
debianEpoch PackageName
name = StateT CabalInfo m CabalInfo
forall s (m :: * -> *). MonadState s m => m s
get StateT CabalInfo m CabalInfo
-> (CabalInfo -> StateT CabalInfo m (Maybe Int))
-> StateT CabalInfo m (Maybe Int)
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Maybe Int -> StateT CabalInfo m (Maybe Int)
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Int -> StateT CabalInfo m (Maybe Int))
-> (CabalInfo -> Maybe Int)
-> CabalInfo
-> StateT CabalInfo m (Maybe Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageName -> Map PackageName Int -> Maybe Int
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup PackageName
name (Map PackageName Int -> Maybe Int)
-> (CabalInfo -> Map PackageName Int) -> CabalInfo -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting (Map PackageName Int) CabalInfo (Map PackageName Int)
-> CabalInfo -> Map PackageName Int
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Map PackageName Int) CabalInfo (Map PackageName Int)
Lens' CabalInfo (Map PackageName Int)
A.epochMap
finalizeSourceName :: (Monad m) => B.PackageType -> CabalT m ()
finalizeSourceName :: forall (m :: * -> *). Monad m => PackageType -> CabalT m ()
finalizeSourceName PackageType
typ =
do DebBase [Char]
debName <- CabalT m DebBase
forall (m :: * -> *). Monad m => CabalT m DebBase
debianNameBase
CompilerFlavor
hc <- Getting CompilerFlavor CabalInfo CompilerFlavor
-> StateT CabalInfo m CompilerFlavor
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const CompilerFlavor DebInfo)
-> CabalInfo -> Const CompilerFlavor CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const CompilerFlavor DebInfo)
-> CabalInfo -> Const CompilerFlavor CabalInfo)
-> ((CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> DebInfo -> Const CompilerFlavor DebInfo)
-> Getting CompilerFlavor CabalInfo CompilerFlavor
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Flags -> Const CompilerFlavor Flags)
-> DebInfo -> Const CompilerFlavor DebInfo
Lens' DebInfo Flags
D.flags ((Flags -> Const CompilerFlavor Flags)
-> DebInfo -> Const CompilerFlavor DebInfo)
-> ((CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> Flags -> Const CompilerFlavor Flags)
-> (CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> DebInfo
-> Const CompilerFlavor DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> Flags -> Const CompilerFlavor Flags
Lens' Flags CompilerFlavor
compilerFlavor)
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe SrcPkgName -> f (Maybe SrcPkgName))
-> DebInfo -> f DebInfo)
-> (Maybe SrcPkgName -> f (Maybe SrcPkgName))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe SrcPkgName -> f (Maybe SrcPkgName)) -> DebInfo -> f DebInfo
Lens' DebInfo (Maybe SrcPkgName)
D.sourcePackageName) (forall {f :: * -> *}.
Functor f =>
(Maybe SrcPkgName -> f (Maybe SrcPkgName))
-> CabalInfo -> f CabalInfo)
-> Maybe SrcPkgName -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?=
SrcPkgName -> Maybe SrcPkgName
forall a. a -> Maybe a
Just ([Char] -> SrcPkgName
SrcPkgName (case (CompilerFlavor
hc, PackageType
typ) of
(CompilerFlavor
GHC, PackageType
B.HaskellSource) -> [Char]
"haskell-" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
debName
(CompilerFlavor
GHCJS, PackageType
B.HaskellSource) -> [Char]
"ghcjs-" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
debName
(CompilerFlavor
_, PackageType
B.Source) -> [Char]
debName
(CompilerFlavor, PackageType)
_ -> [Char] -> [Char]
forall a. HasCallStack => [Char] -> a
error ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ [Char]
"finalizeSourceName: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ PackageType -> [Char]
forall a. Show a => a -> [Char]
show PackageType
typ))
finalizeMaintainer :: Monad m => Maybe NameAddr -> CabalT m ()
finalizeMaintainer :: forall (m :: * -> *). Monad m => Maybe NameAddr -> CabalT m ()
finalizeMaintainer Maybe NameAddr
currentUser = do
Bool
o <- Getting Bool CabalInfo Bool -> StateT CabalInfo m Bool
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const Bool DebInfo)
-> CabalInfo -> Const Bool CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const Bool DebInfo)
-> CabalInfo -> Const Bool CabalInfo)
-> ((Bool -> Const Bool Bool) -> DebInfo -> Const Bool DebInfo)
-> Getting Bool CabalInfo Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Bool -> Const Bool Bool) -> DebInfo -> Const Bool DebInfo
Lens' DebInfo Bool
D.official)
PackageDescription
pkgDesc <- Getting PackageDescription CabalInfo PackageDescription
-> StateT CabalInfo m PackageDescription
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting PackageDescription CabalInfo PackageDescription
Lens' CabalInfo PackageDescription
A.packageDescription
Maybe NameAddr
maintainerOption <- Getting (Maybe NameAddr) CabalInfo (Maybe NameAddr)
-> StateT CabalInfo m (Maybe NameAddr)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe NameAddr) DebInfo)
-> CabalInfo -> Const (Maybe NameAddr) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe NameAddr) DebInfo)
-> CabalInfo -> Const (Maybe NameAddr) CabalInfo)
-> ((Maybe NameAddr -> Const (Maybe NameAddr) (Maybe NameAddr))
-> DebInfo -> Const (Maybe NameAddr) DebInfo)
-> Getting (Maybe NameAddr) CabalInfo (Maybe NameAddr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe NameAddr -> Const (Maybe NameAddr) (Maybe NameAddr))
-> DebInfo -> Const (Maybe NameAddr) DebInfo
Lens' DebInfo (Maybe NameAddr)
D.maintainerOption)
[NameAddr]
uploadersOption <- Getting [NameAddr] CabalInfo [NameAddr]
-> StateT CabalInfo m [NameAddr]
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const [NameAddr] DebInfo)
-> CabalInfo -> Const [NameAddr] CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const [NameAddr] DebInfo)
-> CabalInfo -> Const [NameAddr] CabalInfo)
-> (([NameAddr] -> Const [NameAddr] [NameAddr])
-> DebInfo -> Const [NameAddr] DebInfo)
-> Getting [NameAddr] CabalInfo [NameAddr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([NameAddr] -> Const [NameAddr] [NameAddr])
-> DebInfo -> Const [NameAddr] DebInfo
Lens' DebInfo [NameAddr]
D.uploadersOption)
#if MIN_VERSION_Cabal(3,2,0)
let toString :: ShortText -> [Char]
toString = ShortText -> [Char]
ST.fromShortText
#else
let toString = id
#endif
cabalAuthorString :: [Char]
cabalAuthorString = (Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (\ Char
c -> Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
',' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\n') (ShortText -> [Char]
toString (PackageDescription -> ShortText
Cabal.author PackageDescription
pkgDesc))
cabalMaintainerString :: [Char]
cabalMaintainerString = (Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (\ Char
c -> Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
',' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\n') (ShortText -> [Char]
toString (PackageDescription -> ShortText
Cabal.maintainer PackageDescription
pkgDesc))
cabalMaintainerString' :: [Char]
cabalMaintainerString' = [Char]
cabalAuthorString [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
" <" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
cabalMaintainerString [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
">"
cabalMaintainerString'' :: [Char]
cabalMaintainerString'' = [Char]
cabalAuthorString [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
" " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
cabalMaintainerString
Maybe NameAddr
changelogSignature <-
do Maybe ChangeLog
log <- Getting (Maybe ChangeLog) CabalInfo (Maybe ChangeLog)
-> StateT CabalInfo m (Maybe ChangeLog)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe ChangeLog) DebInfo)
-> CabalInfo -> Const (Maybe ChangeLog) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe ChangeLog) DebInfo)
-> CabalInfo -> Const (Maybe ChangeLog) CabalInfo)
-> ((Maybe ChangeLog -> Const (Maybe ChangeLog) (Maybe ChangeLog))
-> DebInfo -> Const (Maybe ChangeLog) DebInfo)
-> Getting (Maybe ChangeLog) CabalInfo (Maybe ChangeLog)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe ChangeLog -> Const (Maybe ChangeLog) (Maybe ChangeLog))
-> DebInfo -> Const (Maybe ChangeLog) DebInfo
Lens' DebInfo (Maybe ChangeLog)
D.changelog)
case Maybe ChangeLog
log of
Just (ChangeLog (ChangeLogEntry
entry : [ChangeLogEntry]
_)) ->
case ([Char] -> Either [Char] NameAddr
parseMaintainer (ChangeLogEntry -> [Char]
logWho ChangeLogEntry
entry)) of
Left [Char]
_e -> Maybe NameAddr -> StateT CabalInfo m (Maybe NameAddr)
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe NameAddr -> StateT CabalInfo m (Maybe NameAddr))
-> Maybe NameAddr -> StateT CabalInfo m (Maybe NameAddr)
forall a b. (a -> b) -> a -> b
$ Maybe NameAddr
forall a. Maybe a
Nothing
Right NameAddr
x -> Maybe NameAddr -> StateT CabalInfo m (Maybe NameAddr)
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (NameAddr -> Maybe NameAddr
forall a. a -> Maybe a
Just NameAddr
x)
Maybe ChangeLog
_ -> Maybe NameAddr -> StateT CabalInfo m (Maybe NameAddr)
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe NameAddr
forall a. Maybe a
Nothing
case Bool
o of
Bool
True -> do
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo -> Identity DebInfo)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo -> Identity CabalInfo)
-> Either [Char] NameAddr -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right NameAddr
haskellMaintainer
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> (([NameAddr] -> Identity [NameAddr])
-> DebInfo -> Identity DebInfo)
-> ([NameAddr] -> Identity [NameAddr])
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> (([NameAddr] -> Identity [NameAddr])
-> SourceDebDescription -> Identity SourceDebDescription)
-> ([NameAddr] -> Identity [NameAddr])
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([NameAddr] -> Identity [NameAddr])
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription [NameAddr]
S.uploaders) (([NameAddr] -> Identity [NameAddr])
-> CabalInfo -> Identity CabalInfo)
-> ([NameAddr] -> [NameAddr]) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= [NameAddr] -> [NameAddr] -> [NameAddr]
forall a. [a] -> [a] -> [a]
whenEmpty ([NameAddr]
-> (NameAddr -> [NameAddr]) -> Maybe NameAddr -> [NameAddr]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (NameAddr -> [NameAddr] -> [NameAddr]
forall a. a -> [a] -> [a]
: []) Maybe NameAddr
currentUser)
Bool
False -> do
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo -> Identity DebInfo)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo -> Identity CabalInfo)
-> (Either [Char] NameAddr -> Either [Char] NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> Either [Char] NameAddr)
-> (NameAddr -> Either [Char] NameAddr)
-> Either [Char] NameAddr
-> Either [Char] NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
x -> Either [Char] NameAddr
-> (NameAddr -> Either [Char] NameAddr)
-> Maybe NameAddr
-> Either [Char] NameAddr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Char] -> Either [Char] NameAddr
forall a b. a -> Either a b
Left [Char]
x) NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right Maybe NameAddr
maintainerOption) NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo -> Identity DebInfo)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo -> Identity CabalInfo)
-> (Either [Char] NameAddr -> Either [Char] NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> Either [Char] NameAddr)
-> (NameAddr -> Either [Char] NameAddr)
-> Either [Char] NameAddr
-> Either [Char] NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
_ -> [Char] -> Either [Char] NameAddr
parseMaintainer [Char]
cabalMaintainerString) NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo -> Identity DebInfo)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo -> Identity CabalInfo)
-> (Either [Char] NameAddr -> Either [Char] NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> Either [Char] NameAddr)
-> (NameAddr -> Either [Char] NameAddr)
-> Either [Char] NameAddr
-> Either [Char] NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
_ -> [Char] -> Either [Char] NameAddr
parseMaintainer [Char]
cabalMaintainerString') NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo -> Identity DebInfo)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo -> Identity CabalInfo)
-> (Either [Char] NameAddr -> Either [Char] NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> Either [Char] NameAddr)
-> (NameAddr -> Either [Char] NameAddr)
-> Either [Char] NameAddr
-> Either [Char] NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
_ -> [Char] -> Either [Char] NameAddr
parseMaintainer [Char]
cabalMaintainerString'') NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo -> Identity DebInfo)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo -> Identity CabalInfo)
-> (Either [Char] NameAddr -> Either [Char] NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> Either [Char] NameAddr)
-> (NameAddr -> Either [Char] NameAddr)
-> Either [Char] NameAddr
-> Either [Char] NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
e -> case [Char] -> Either [Char] NameAddr
parseMaintainer [Char]
cabalAuthorString of
Right NameAddr
x | NameAddr -> [Char]
nameAddr_addr NameAddr
x [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
cabalMaintainerString -> NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right NameAddr
x
Right NameAddr
_ -> [Char] -> Either [Char] NameAddr
forall a b. a -> Either a b
Left [Char]
e
Left [Char]
x -> [Char] -> Either [Char] NameAddr
forall a b. a -> Either a b
Left [Char]
x) NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo -> Identity DebInfo)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo -> Identity CabalInfo)
-> (Either [Char] NameAddr -> Either [Char] NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> Either [Char] NameAddr)
-> (NameAddr -> Either [Char] NameAddr)
-> Either [Char] NameAddr
-> Either [Char] NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
e -> case [Char] -> Either [Char] NameAddr
parseMaintainer [Char]
cabalAuthorString of
Right (NameAddr {nameAddr_name :: NameAddr -> Maybe [Char]
nameAddr_name = Just [Char]
name}) -> [Char] -> Either [Char] NameAddr
parseMaintainer ([Char]
name [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" <" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
cabalMaintainerString [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
">")
Right NameAddr
_ -> [Char] -> Either [Char] NameAddr
forall a b. a -> Either a b
Left [Char]
e
Left [Char]
x -> [Char] -> Either [Char] NameAddr
forall a b. a -> Either a b
Left [Char]
x) NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo -> Identity DebInfo)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo -> Identity CabalInfo)
-> (Either [Char] NameAddr -> Either [Char] NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> Either [Char] NameAddr)
-> (NameAddr -> Either [Char] NameAddr)
-> Either [Char] NameAddr
-> Either [Char] NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
e -> Either [Char] NameAddr
-> (NameAddr -> Either [Char] NameAddr)
-> Maybe NameAddr
-> Either [Char] NameAddr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Char] -> Either [Char] NameAddr
forall a b. a -> Either a b
Left [Char]
e) NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right Maybe NameAddr
currentUser) NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo -> Identity DebInfo)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo -> Identity CabalInfo)
-> (Either [Char] NameAddr -> Either [Char] NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> Either [Char] NameAddr)
-> (NameAddr -> Either [Char] NameAddr)
-> Either [Char] NameAddr
-> Either [Char] NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
e -> Either [Char] NameAddr
-> (NameAddr -> Either [Char] NameAddr)
-> Maybe NameAddr
-> Either [Char] NameAddr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Char] -> Either [Char] NameAddr
forall a b. a -> Either a b
Left [Char]
e) NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right Maybe NameAddr
changelogSignature) NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo -> Identity DebInfo)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) ((Either [Char] NameAddr -> Identity (Either [Char] NameAddr))
-> CabalInfo -> Identity CabalInfo)
-> (Either [Char] NameAddr -> Either [Char] NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> Either [Char] NameAddr)
-> (NameAddr -> Either [Char] NameAddr)
-> Either [Char] NameAddr
-> Either [Char] NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
_ -> [Char] -> Either [Char] NameAddr
forall a b. a -> Either a b
Left ([Char]
"Unable to construct a debian maintainer, using default. Cabal maintainer strings tried:\n " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
[Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
cabalMaintainerString [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
", " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
cabalMaintainerString' [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
", " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
cabalMaintainerString'' [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
[Char]
", currentUser: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Maybe NameAddr -> [Char]
forall a. Show a => a -> [Char]
show Maybe NameAddr
currentUser)) NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> (([NameAddr] -> Identity [NameAddr])
-> DebInfo -> Identity DebInfo)
-> ([NameAddr] -> Identity [NameAddr])
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> (([NameAddr] -> Identity [NameAddr])
-> SourceDebDescription -> Identity SourceDebDescription)
-> ([NameAddr] -> Identity [NameAddr])
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([NameAddr] -> Identity [NameAddr])
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription [NameAddr]
S.uploaders) (([NameAddr] -> Identity [NameAddr])
-> CabalInfo -> Identity CabalInfo)
-> ([NameAddr] -> [NameAddr]) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= [NameAddr] -> [NameAddr] -> [NameAddr]
forall a. [a] -> [a] -> [a]
whenEmpty [NameAddr]
uploadersOption
whenEmpty :: [a] -> [a] -> [a]
whenEmpty :: forall a. [a] -> [a] -> [a]
whenEmpty [a]
d [] = [a]
d
whenEmpty [a]
_ [a]
l = [a]
l
finalizeControl :: (MonadFail m) => Maybe NameAddr -> CabalT m ()
finalizeControl :: forall (m :: * -> *). MonadFail m => Maybe NameAddr -> CabalT m ()
finalizeControl Maybe NameAddr
currentUser =
do Maybe NameAddr -> CabalT m ()
forall (m :: * -> *). Monad m => Maybe NameAddr -> CabalT m ()
finalizeMaintainer Maybe NameAddr
currentUser
Just SrcPkgName
src <- Getting (Maybe SrcPkgName) CabalInfo (Maybe SrcPkgName)
-> StateT CabalInfo m (Maybe SrcPkgName)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe SrcPkgName) DebInfo)
-> CabalInfo -> Const (Maybe SrcPkgName) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe SrcPkgName) DebInfo)
-> CabalInfo -> Const (Maybe SrcPkgName) CabalInfo)
-> ((Maybe SrcPkgName
-> Const (Maybe SrcPkgName) (Maybe SrcPkgName))
-> DebInfo -> Const (Maybe SrcPkgName) DebInfo)
-> Getting (Maybe SrcPkgName) CabalInfo (Maybe SrcPkgName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe SrcPkgName -> Const (Maybe SrcPkgName) (Maybe SrcPkgName))
-> DebInfo -> Const (Maybe SrcPkgName) DebInfo
Lens' DebInfo (Maybe SrcPkgName)
D.sourcePackageName)
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Maybe SrcPkgName -> Identity (Maybe SrcPkgName))
-> DebInfo -> Identity DebInfo)
-> (Maybe SrcPkgName -> Identity (Maybe SrcPkgName))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Maybe SrcPkgName -> Identity (Maybe SrcPkgName))
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Maybe SrcPkgName -> Identity (Maybe SrcPkgName))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe SrcPkgName -> Identity (Maybe SrcPkgName))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Maybe SrcPkgName)
S.source) ((Maybe SrcPkgName -> Identity (Maybe SrcPkgName))
-> CabalInfo -> Identity CabalInfo)
-> Maybe SrcPkgName -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= SrcPkgName -> Maybe SrcPkgName
forall a. a -> Maybe a
Just SrcPkgName
src
Text
desc' <- CabalT m Text
forall (m :: * -> *). Monad m => CabalT m Text
describe
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe Text -> f (Maybe Text)) -> DebInfo -> f DebInfo)
-> (Maybe Text -> f (Maybe Text))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> f SourceDebDescription)
-> DebInfo -> f DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> f SourceDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe Text -> f (Maybe Text))
-> SourceDebDescription -> f SourceDebDescription)
-> (Maybe Text -> f (Maybe Text))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Text -> f (Maybe Text))
-> SourceDebDescription -> f SourceDebDescription
Lens' SourceDebDescription (Maybe Text)
S.xDescription) (forall {f :: * -> *}.
Functor f =>
(Maybe Text -> f (Maybe Text)) -> CabalInfo -> f CabalInfo)
-> Maybe Text -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Text -> Maybe Text
forall a. a -> Maybe a
Just Text
desc'
describe :: Monad m => CabalT m Text
describe :: forall (m :: * -> *). Monad m => CabalT m Text
describe =
do PackageDescription
p <- Getting PackageDescription CabalInfo PackageDescription
-> StateT CabalInfo m PackageDescription
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting PackageDescription CabalInfo PackageDescription
Lens' CabalInfo PackageDescription
A.packageDescription
Text -> CabalT m Text
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> CabalT m Text) -> Text -> CabalT m Text
forall a b. (a -> b) -> a -> b
$
PackageDescription -> Text
debianDescriptionBase PackageDescription
p
debianDescriptionBase :: PackageDescription -> Text
debianDescriptionBase :: PackageDescription -> Text
debianDescriptionBase PackageDescription
p =
[Char] -> Text
pack ([Char] -> Text) -> [Char] -> Text
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
List.intercalate [Char]
"\n " ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$ ([Char]
synop' [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [[Char]]
desc')
where
synop' :: [Char]
synop' = if [Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null [Char]
synop Bool -> Bool -> Bool
&& [[Char]] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Char]]
desc' Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
1
then [Char]
"WARNING: No synopsis available for package " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ PackageIdentifier -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow (PackageDescription -> PackageIdentifier
package PackageDescription
p)
else [Char]
synop
synop :: String
synop :: [Char]
synop = [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
List.intercalate [Char]
" " ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$ ([Char] -> [Char]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
dropWhileEnd Char -> Bool
isSpace) ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
lines ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ ShortText -> [Char]
toString (ShortText -> [Char]) -> ShortText -> [Char]
forall a b. (a -> b) -> a -> b
$ PackageDescription -> ShortText
synopsis PackageDescription
p
desc' :: [String]
desc' :: [[Char]]
desc' = ([Char] -> [Char]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
List.map [Char] -> [Char]
forall {t :: * -> *} {a}.
(Foldable t, IsString (t a)) =>
t a -> t a
addDot ([[Char]] -> [[Char]])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
stripWith [Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ ([Char] -> [Char]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
dropWhileEnd Char -> Bool
isSpace) ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
lines ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ ShortText -> [Char]
toString (ShortText -> [Char]) -> ShortText -> [Char]
forall a b. (a -> b) -> a -> b
$ PackageDescription -> ShortText
Cabal.description PackageDescription
p
addDot :: t a -> t a
addDot t a
line = if t a -> Bool
forall a. t a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null t a
line then t a
"." else t a
line
#if MIN_VERSION_Cabal(3,2,0)
toString :: ShortText -> [Char]
toString = ShortText -> [Char]
ST.fromShortText
#else
toString = id
#endif
finalizeChangelog :: (Monad m) => String -> Maybe NameAddr -> CabalT m ()
finalizeChangelog :: forall (m :: * -> *).
Monad m =>
[Char] -> Maybe NameAddr -> CabalT m ()
finalizeChangelog [Char]
date Maybe NameAddr
currentUser =
do Maybe NameAddr -> CabalT m ()
forall (m :: * -> *). Monad m => Maybe NameAddr -> CabalT m ()
finalizeMaintainer Maybe NameAddr
currentUser
DebianVersion
ver <- CabalT m DebianVersion
forall (m :: * -> *). Monad m => CabalT m DebianVersion
debianVersion
Maybe SrcPkgName
src <- Getting (Maybe SrcPkgName) CabalInfo (Maybe SrcPkgName)
-> StateT CabalInfo m (Maybe SrcPkgName)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe SrcPkgName) DebInfo)
-> CabalInfo -> Const (Maybe SrcPkgName) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe SrcPkgName) DebInfo)
-> CabalInfo -> Const (Maybe SrcPkgName) CabalInfo)
-> ((Maybe SrcPkgName
-> Const (Maybe SrcPkgName) (Maybe SrcPkgName))
-> DebInfo -> Const (Maybe SrcPkgName) DebInfo)
-> Getting (Maybe SrcPkgName) CabalInfo (Maybe SrcPkgName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe SrcPkgName -> Const (Maybe SrcPkgName) (Maybe SrcPkgName))
-> DebInfo -> Const (Maybe SrcPkgName) DebInfo
Lens' DebInfo (Maybe SrcPkgName)
D.sourcePackageName)
[NameAddr]
debianUploaders <- Getting [NameAddr] CabalInfo [NameAddr]
-> StateT CabalInfo m [NameAddr]
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const [NameAddr] DebInfo)
-> CabalInfo -> Const [NameAddr] CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const [NameAddr] DebInfo)
-> CabalInfo -> Const [NameAddr] CabalInfo)
-> (([NameAddr] -> Const [NameAddr] [NameAddr])
-> DebInfo -> Const [NameAddr] DebInfo)
-> Getting [NameAddr] CabalInfo [NameAddr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Const [NameAddr] SourceDebDescription)
-> DebInfo -> Const [NameAddr] DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Const [NameAddr] SourceDebDescription)
-> DebInfo -> Const [NameAddr] DebInfo)
-> (([NameAddr] -> Const [NameAddr] [NameAddr])
-> SourceDebDescription -> Const [NameAddr] SourceDebDescription)
-> ([NameAddr] -> Const [NameAddr] [NameAddr])
-> DebInfo
-> Const [NameAddr] DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([NameAddr] -> Const [NameAddr] [NameAddr])
-> SourceDebDescription -> Const [NameAddr] SourceDebDescription
Lens' SourceDebDescription [NameAddr]
S.uploaders)
Either [Char] NameAddr
debianMaintainer <- Getting (Either [Char] NameAddr) CabalInfo (Either [Char] NameAddr)
-> StateT CabalInfo m (Either [Char] NameAddr)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Either [Char] NameAddr) DebInfo)
-> CabalInfo -> Const (Either [Char] NameAddr) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Either [Char] NameAddr) DebInfo)
-> CabalInfo -> Const (Either [Char] NameAddr) CabalInfo)
-> ((Either [Char] NameAddr
-> Const (Either [Char] NameAddr) (Either [Char] NameAddr))
-> DebInfo -> Const (Either [Char] NameAddr) DebInfo)
-> Getting
(Either [Char] NameAddr) CabalInfo (Either [Char] NameAddr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription
-> Const (Either [Char] NameAddr) SourceDebDescription)
-> DebInfo -> Const (Either [Char] NameAddr) DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription
-> Const (Either [Char] NameAddr) SourceDebDescription)
-> DebInfo -> Const (Either [Char] NameAddr) DebInfo)
-> ((Either [Char] NameAddr
-> Const (Either [Char] NameAddr) (Either [Char] NameAddr))
-> SourceDebDescription
-> Const (Either [Char] NameAddr) SourceDebDescription)
-> (Either [Char] NameAddr
-> Const (Either [Char] NameAddr) (Either [Char] NameAddr))
-> DebInfo
-> Const (Either [Char] NameAddr) DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either [Char] NameAddr
-> Const (Either [Char] NameAddr) (Either [Char] NameAddr))
-> SourceDebDescription
-> Const (Either [Char] NameAddr) SourceDebDescription
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer)
let nameToUse :: Either [Char] NameAddr
nameToUse | (NameAddr
n:[NameAddr]
_) <- [NameAddr]
debianUploaders = NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right NameAddr
n
| Bool
otherwise = Either [Char] NameAddr
debianMaintainer
Maybe [[Text]]
cmts <- Getting (Maybe [[Text]]) CabalInfo (Maybe [[Text]])
-> StateT CabalInfo m (Maybe [[Text]])
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe [[Text]]) DebInfo)
-> CabalInfo -> Const (Maybe [[Text]]) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe [[Text]]) DebInfo)
-> CabalInfo -> Const (Maybe [[Text]]) CabalInfo)
-> ((Maybe [[Text]] -> Const (Maybe [[Text]]) (Maybe [[Text]]))
-> DebInfo -> Const (Maybe [[Text]]) DebInfo)
-> Getting (Maybe [[Text]]) CabalInfo (Maybe [[Text]])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe [[Text]] -> Const (Maybe [[Text]]) (Maybe [[Text]]))
-> DebInfo -> Const (Maybe [[Text]]) DebInfo
Lens' DebInfo (Maybe [[Text]])
D.comments)
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Maybe ChangeLog -> Identity (Maybe ChangeLog))
-> DebInfo -> Identity DebInfo)
-> (Maybe ChangeLog -> Identity (Maybe ChangeLog))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe ChangeLog -> Identity (Maybe ChangeLog))
-> DebInfo -> Identity DebInfo
Lens' DebInfo (Maybe ChangeLog)
D.changelog) ((Maybe ChangeLog -> Identity (Maybe ChangeLog))
-> CabalInfo -> Identity CabalInfo)
-> (Maybe ChangeLog -> Maybe ChangeLog) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (ChangeLog -> ChangeLog) -> Maybe ChangeLog -> Maybe ChangeLog
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (DebianVersion -> ChangeLog -> ChangeLog
dropFutureEntries DebianVersion
ver)
let msg :: Text
msg = Text
"Initial release"
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Maybe ChangeLog -> Identity (Maybe ChangeLog))
-> DebInfo -> Identity DebInfo)
-> (Maybe ChangeLog -> Identity (Maybe ChangeLog))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe ChangeLog -> Identity (Maybe ChangeLog))
-> DebInfo -> Identity DebInfo
Lens' DebInfo (Maybe ChangeLog)
D.changelog) ((Maybe ChangeLog -> Identity (Maybe ChangeLog))
-> CabalInfo -> Identity CabalInfo)
-> (Maybe ChangeLog -> Maybe ChangeLog) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= Maybe SrcPkgName
-> DebianVersion
-> Maybe [[Text]]
-> Either [Char] NameAddr
-> Text
-> Maybe ChangeLog
-> Maybe ChangeLog
fixLog Maybe SrcPkgName
src DebianVersion
ver Maybe [[Text]]
cmts Either [Char] NameAddr
nameToUse Text
msg
where
fixLog :: Maybe SrcPkgName -> V.DebianVersion -> Maybe [[Text]] -> Either String NameAddr -> Text -> Maybe ChangeLog -> Maybe ChangeLog
fixLog :: Maybe SrcPkgName
-> DebianVersion
-> Maybe [[Text]]
-> Either [Char] NameAddr
-> Text
-> Maybe ChangeLog
-> Maybe ChangeLog
fixLog Maybe SrcPkgName
src DebianVersion
ver Maybe [[Text]]
cmts Either [Char] NameAddr
_maint Text
_ (Just (ChangeLog (entry :: ChangeLogEntry
entry@Entry{} : [ChangeLogEntry]
older)))
| ChangeLogEntry -> DebianVersion
logVersion ChangeLogEntry
entry DebianVersion -> DebianVersion -> Bool
forall a. Eq a => a -> a -> Bool
== DebianVersion
ver =
let entry' :: ChangeLogEntry
entry' = ChangeLogEntry
entry { logPackage = show (pretty (PP src))
, logComments = logComments entry ++ "\n" ++
(List.unlines $ List.map ((" * " <>) . List.intercalate "\n " . List.map unpack) (fromMaybe [] cmts))
} in
ChangeLog -> Maybe ChangeLog
forall a. a -> Maybe a
Just ([ChangeLogEntry] -> ChangeLog
ChangeLog (ChangeLogEntry
entry' ChangeLogEntry -> [ChangeLogEntry] -> [ChangeLogEntry]
forall a. a -> [a] -> [a]
: [ChangeLogEntry]
older))
fixLog Maybe SrcPkgName
_src DebianVersion
_ver Maybe [[Text]]
_cmts Either [Char] NameAddr
_maint Text
_ (Just (ChangeLog (entry :: ChangeLogEntry
entry@WhiteSpace{} : [ChangeLogEntry]
older))) =
ChangeLog -> Maybe ChangeLog
forall a. a -> Maybe a
Just ([ChangeLogEntry] -> ChangeLog
ChangeLog (ChangeLogEntry
entry ChangeLogEntry -> [ChangeLogEntry] -> [ChangeLogEntry]
forall a. a -> [a] -> [a]
: [ChangeLogEntry]
older))
fixLog Maybe SrcPkgName
src DebianVersion
ver Maybe [[Text]]
cmts Either [Char] NameAddr
maint Text
msg Maybe ChangeLog
log =
let entry :: ChangeLogEntry
entry = Entry { logPackage :: [Char]
logPackage = Doc -> [Char]
forall a. Show a => a -> [Char]
show (PP (Maybe SrcPkgName) -> Doc
forall a. Pretty a => a -> Doc
pretty (Maybe SrcPkgName -> PP (Maybe SrcPkgName)
forall a. a -> PP a
PP Maybe SrcPkgName
src))
, logVersion :: DebianVersion
logVersion = DebianVersion
ver
, logDists :: [Codename]
logDists = [[Char] -> Codename
parseCodename [Char]
"UNRELEASED"]
, logUrgency :: [Char]
logUrgency = [Char]
"low"
, logComments :: [Char]
logComments =
[[Char]] -> [Char]
List.unlines ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$ ([Text] -> [Char]) -> [[Text]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
List.map (([Char]
" * " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<>) ([Char] -> [Char]) -> ([Text] -> [Char]) -> [Text] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
List.intercalate [Char]
"\n " ([[Char]] -> [Char]) -> ([Text] -> [[Char]]) -> [Text] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> [Char]) -> [Text] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
List.map Text -> [Char]
unpack) ([[Text]] -> Maybe [[Text]] -> [[Text]]
forall a. a -> Maybe a -> a
fromMaybe [[Text
msg]] Maybe [[Text]]
cmts)
, logWho :: [Char]
logWho = ([Char] -> [Char])
-> (NameAddr -> [Char]) -> Either [Char] NameAddr -> [Char]
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
_ -> NameAddr -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow NameAddr
maintainerOfLastResort) NameAddr -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow Either [Char] NameAddr
maint
, logDate :: [Char]
logDate = [Char]
date } in
ChangeLog -> Maybe ChangeLog
forall a. a -> Maybe a
Just ([ChangeLogEntry] -> ChangeLog
ChangeLog (ChangeLogEntry
entry ChangeLogEntry -> [ChangeLogEntry] -> [ChangeLogEntry]
forall a. a -> [a] -> [a]
: [ChangeLogEntry]
-> (ChangeLog -> [ChangeLogEntry])
-> Maybe ChangeLog
-> [ChangeLogEntry]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\ (ChangeLog [ChangeLogEntry]
entries) -> [ChangeLogEntry]
entries) Maybe ChangeLog
log))
addExtraLibDependencies :: (Monad m) => CompilerFlavor -> CabalT m ()
CompilerFlavor
hc =
do PackageDescription
pkgDesc <- Getting PackageDescription CabalInfo PackageDescription
-> StateT CabalInfo m PackageDescription
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting PackageDescription CabalInfo PackageDescription
Lens' CabalInfo PackageDescription
A.packageDescription
BinPkgName
devName <- PackageType -> CompilerFlavor -> CabalT m BinPkgName
forall (m :: * -> *) name.
(Monad m, PkgName name) =>
PackageType -> CompilerFlavor -> CabalT m name
debianName PackageType
B.Development CompilerFlavor
hc
Map [Char] Relations
libMap <- Getting (Map [Char] Relations) CabalInfo (Map [Char] Relations)
-> StateT CabalInfo m (Map [Char] Relations)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Map [Char] Relations) DebInfo)
-> CabalInfo -> Const (Map [Char] Relations) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Map [Char] Relations) DebInfo)
-> CabalInfo -> Const (Map [Char] Relations) CabalInfo)
-> ((Map [Char] Relations
-> Const (Map [Char] Relations) (Map [Char] Relations))
-> DebInfo -> Const (Map [Char] Relations) DebInfo)
-> Getting (Map [Char] Relations) CabalInfo (Map [Char] Relations)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map [Char] Relations
-> Const (Map [Char] Relations) (Map [Char] Relations))
-> DebInfo -> Const (Map [Char] Relations) DebInfo
Lens' DebInfo (Map [Char] Relations)
D.extraLibMap)
[BinPkgName]
binNames <- (BinaryDebDescription -> BinPkgName)
-> [BinaryDebDescription] -> [BinPkgName]
forall a b. (a -> b) -> [a] -> [b]
List.map (Getting BinPkgName BinaryDebDescription BinPkgName
-> BinaryDebDescription -> BinPkgName
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting BinPkgName BinaryDebDescription BinPkgName
Lens' BinaryDebDescription BinPkgName
B.package) ([BinaryDebDescription] -> [BinPkgName])
-> StateT CabalInfo m [BinaryDebDescription]
-> StateT CabalInfo m [BinPkgName]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Getting [BinaryDebDescription] CabalInfo [BinaryDebDescription]
-> StateT CabalInfo m [BinaryDebDescription]
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const [BinaryDebDescription] DebInfo)
-> CabalInfo -> Const [BinaryDebDescription] CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const [BinaryDebDescription] DebInfo)
-> CabalInfo -> Const [BinaryDebDescription] CabalInfo)
-> (([BinaryDebDescription]
-> Const [BinaryDebDescription] [BinaryDebDescription])
-> DebInfo -> Const [BinaryDebDescription] DebInfo)
-> Getting [BinaryDebDescription] CabalInfo [BinaryDebDescription]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription
-> Const [BinaryDebDescription] SourceDebDescription)
-> DebInfo -> Const [BinaryDebDescription] DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription
-> Const [BinaryDebDescription] SourceDebDescription)
-> DebInfo -> Const [BinaryDebDescription] DebInfo)
-> (([BinaryDebDescription]
-> Const [BinaryDebDescription] [BinaryDebDescription])
-> SourceDebDescription
-> Const [BinaryDebDescription] SourceDebDescription)
-> ([BinaryDebDescription]
-> Const [BinaryDebDescription] [BinaryDebDescription])
-> DebInfo
-> Const [BinaryDebDescription] DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([BinaryDebDescription]
-> Const [BinaryDebDescription] [BinaryDebDescription])
-> SourceDebDescription
-> Const [BinaryDebDescription] SourceDebDescription
Lens' SourceDebDescription [BinaryDebDescription]
S.binaryPackages)
Bool -> CabalT m () -> CabalT m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when ((BinPkgName -> Bool) -> [BinPkgName] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (BinPkgName -> BinPkgName -> Bool
forall a. Eq a => a -> a -> Bool
== BinPkgName
devName) [BinPkgName]
binNames) (((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Relations -> Identity Relations)
-> DebInfo -> Identity DebInfo)
-> (Relations -> Identity Relations)
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
devName ((BinaryDebDescription -> Identity BinaryDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Relations -> Identity Relations)
-> BinaryDebDescription -> Identity BinaryDebDescription)
-> (Relations -> Identity Relations)
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PackageRelations -> Identity PackageRelations)
-> BinaryDebDescription -> Identity BinaryDebDescription
Lens' BinaryDebDescription PackageRelations
B.relations ((PackageRelations -> Identity PackageRelations)
-> BinaryDebDescription -> Identity BinaryDebDescription)
-> ((Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations)
-> (Relations -> Identity Relations)
-> BinaryDebDescription
-> Identity BinaryDebDescription
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations
Lens' PackageRelations Relations
B.depends) ((Relations -> Identity Relations)
-> CabalInfo -> Identity CabalInfo)
-> (Relations -> Relations) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= \ Relations
deps -> Relations
deps Relations -> Relations -> Relations
forall a. [a] -> [a] -> [a]
++ PackageDescription -> Map [Char] Relations -> Relations
g PackageDescription
pkgDesc Map [Char] Relations
libMap)
where
g :: PackageDescription -> Map String Relations -> Relations
g :: PackageDescription -> Map [Char] Relations -> Relations
g PackageDescription
pkgDesc Map [Char] Relations
libMap = ([Char] -> Relations) -> [[Char]] -> Relations
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Map [Char] Relations -> [Char] -> Relations
devDep Map [Char] Relations
libMap) ([[Char]] -> [[Char]]
forall a. Eq a => [a] -> [a]
nub ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ (BuildInfo -> [[Char]]) -> [BuildInfo] -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap BuildInfo -> [[Char]]
Cabal.extraLibs ([BuildInfo] -> [[Char]]) -> [BuildInfo] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ PackageDescription -> [BuildInfo]
Cabal.allBuildInfo (PackageDescription -> [BuildInfo])
-> PackageDescription -> [BuildInfo]
forall a b. (a -> b) -> a -> b
$ PackageDescription
pkgDesc)
devDep :: Map String Relations -> String -> Relations
devDep :: Map [Char] Relations -> [Char] -> Relations
devDep Map [Char] Relations
libMap [Char]
cab = Relations
-> (Relations -> Relations) -> Maybe Relations -> Relations
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [[BinPkgName -> Maybe VersionReq -> Maybe ArchitectureReq -> Relation
Rel ([Char] -> BinPkgName
BinPkgName ([Char]
"lib" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
cab [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"-dev")) Maybe VersionReq
forall a. Maybe a
Nothing Maybe ArchitectureReq
forall a. Maybe a
Nothing]] Relations -> Relations
forall a. a -> a
id ([Char] -> Map [Char] Relations -> Maybe Relations
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup [Char]
cab Map [Char] Relations
libMap)
checkOfficialSettings :: (Monad m) => CompilerFlavor -> CabalT m ()
checkOfficialSettings :: forall (m :: * -> *). Monad m => CompilerFlavor -> CabalT m ()
checkOfficialSettings CompilerFlavor
flavor =
do Bool
o <- Getting Bool CabalInfo Bool -> StateT CabalInfo m Bool
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const Bool DebInfo)
-> CabalInfo -> Const Bool CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const Bool DebInfo)
-> CabalInfo -> Const Bool CabalInfo)
-> ((Bool -> Const Bool Bool) -> DebInfo -> Const Bool DebInfo)
-> Getting Bool CabalInfo Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Bool -> Const Bool Bool) -> DebInfo -> Const Bool DebInfo
Lens' DebInfo Bool
D.official)
Bool -> CabalT m () -> CabalT m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
o (CabalT m () -> CabalT m ()) -> CabalT m () -> CabalT m ()
forall a b. (a -> b) -> a -> b
$ case CompilerFlavor
flavor of
CompilerFlavor
GHC -> CabalT m ()
forall (m :: * -> *). Monad m => CabalT m ()
officialSettings
CompilerFlavor
_ -> [Char] -> CabalT m ()
forall a. HasCallStack => [Char] -> a
error ([Char] -> CabalT m ()) -> [Char] -> CabalT m ()
forall a b. (a -> b) -> a -> b
$ [Char]
"There is no official packaging for " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ CompilerFlavor -> [Char]
forall a. Show a => a -> [Char]
show CompilerFlavor
flavor
officialSettings :: (Monad m) => CabalT m ()
officialSettings :: forall (m :: * -> *). Monad m => CabalT m ()
officialSettings = do
PackageDescription
pkgDesc <- Getting PackageDescription CabalInfo PackageDescription
-> StateT CabalInfo m PackageDescription
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting PackageDescription CabalInfo PackageDescription
Lens' CabalInfo PackageDescription
A.packageDescription
let cabal :: PackageName
cabal = PackageIdentifier -> PackageName
pkgName (PackageDescription -> PackageIdentifier
Cabal.package PackageDescription
pkgDesc)
LensLike' (Zoomed (StateT DebInfo m) ()) CabalInfo DebInfo
-> StateT DebInfo m () -> CabalT m ()
forall c.
LensLike' (Zoomed (StateT DebInfo m) c) CabalInfo DebInfo
-> StateT DebInfo m c -> StateT CabalInfo m c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike' (Zoomed (StateT DebInfo m) ()) CabalInfo DebInfo
Lens' CabalInfo DebInfo
A.debInfo (StateT DebInfo m () -> CabalT m ())
-> StateT DebInfo m () -> CabalT m ()
forall a b. (a -> b) -> a -> b
$ do
let officialError :: a
officialError = [Char] -> a
forall a. HasCallStack => [Char] -> a
error [Char]
"officialSettings: no sourcePackageName"
(Bool -> Identity Bool) -> DebInfo -> Identity DebInfo
Lens' DebInfo Bool
D.omitProfVersionDeps ((Bool -> Identity Bool) -> DebInfo -> Identity DebInfo)
-> Bool -> StateT DebInfo m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Bool
True
SrcPkgName [Char]
src <- SrcPkgName -> Maybe SrcPkgName -> SrcPkgName
forall a. a -> Maybe a -> a
fromMaybe SrcPkgName
forall {a}. a
officialError (Maybe SrcPkgName -> SrcPkgName)
-> StateT DebInfo m (Maybe SrcPkgName)
-> StateT DebInfo m SrcPkgName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Maybe SrcPkgName -> Const (Maybe SrcPkgName) (Maybe SrcPkgName))
-> DebInfo -> Const (Maybe SrcPkgName) DebInfo)
-> StateT DebInfo m (Maybe SrcPkgName)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Maybe SrcPkgName -> Const (Maybe SrcPkgName) (Maybe SrcPkgName))
-> DebInfo -> Const (Maybe SrcPkgName) DebInfo
Lens' DebInfo (Maybe SrcPkgName)
D.sourcePackageName
let packagesURI :: Text
packagesURI = Text
"https://salsa.debian.org/haskell-team/DHG_packages/tree/master/p/" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
src
LensLike'
(Zoomed (StateT SourceDebDescription m) ())
DebInfo
SourceDebDescription
-> StateT SourceDebDescription m () -> StateT DebInfo m ()
forall c.
LensLike'
(Zoomed (StateT SourceDebDescription m) c)
DebInfo
SourceDebDescription
-> StateT SourceDebDescription m c -> StateT DebInfo m c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom (SourceDebDescription -> Focusing m () SourceDebDescription)
-> DebInfo -> Focusing m () DebInfo
LensLike'
(Zoomed (StateT SourceDebDescription m) ())
DebInfo
SourceDebDescription
Lens' DebInfo SourceDebDescription
D.control (StateT SourceDebDescription m () -> StateT DebInfo m ())
-> StateT SourceDebDescription m () -> StateT DebInfo m ()
forall a b. (a -> b) -> a -> b
$ do
(Maybe StandardsVersion -> f (Maybe StandardsVersion))
-> SourceDebDescription -> f SourceDebDescription
Lens' SourceDebDescription (Maybe StandardsVersion)
S.standardsVersion Lens' SourceDebDescription (Maybe StandardsVersion)
-> Maybe StandardsVersion -> StateT SourceDebDescription m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= StandardsVersion -> Maybe StandardsVersion
forall a. a -> Maybe a
Just ([Char] -> StandardsVersion
parseStandardsVersion [Char]
"4.6.2")
(Maybe Text -> f (Maybe Text))
-> SourceDebDescription -> f SourceDebDescription
Lens' SourceDebDescription (Maybe Text)
S.homepage Lens' SourceDebDescription (Maybe Text)
-> Maybe Text -> StateT SourceDebDescription m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Text -> Maybe Text
forall a. a -> Maybe a
Just (Text
"https://hackage.haskell.org/package/" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack (PackageName -> [Char]
unPackageName PackageName
cabal))
(Set VersionControlSpec -> Identity (Set VersionControlSpec))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Set VersionControlSpec)
S.vcsFields ((Set VersionControlSpec -> Identity (Set VersionControlSpec))
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Set VersionControlSpec -> Set VersionControlSpec)
-> StateT SourceDebDescription m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= Set VersionControlSpec
-> Set VersionControlSpec -> Set VersionControlSpec
forall a. Ord a => Set a -> Set a -> Set a
Set.union ([VersionControlSpec] -> Set VersionControlSpec
forall a. Ord a => [a] -> Set a
Set.fromList
[ Text -> VersionControlSpec
S.VCSBrowser Text
packagesURI
, Text -> VersionControlSpec
S.VCSGit (Text
"https://salsa.debian.org/haskell-team/DHG_packages.git [p/" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
src Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"]")
])
putBuildDeps :: (MonadIO m) => (Relations -> Relations) -> PackageDescription -> CabalT m ()
putBuildDeps :: forall (m :: * -> *).
MonadIO m =>
(Relations -> Relations) -> PackageDescription -> CabalT m ()
putBuildDeps Relations -> Relations
finalizeRelations PackageDescription
pkgDesc =
do Relations
deps <- PackageDescription -> CabalT m Relations
forall (m :: * -> *).
MonadIO m =>
PackageDescription -> CabalT m Relations
debianBuildDeps PackageDescription
pkgDesc CabalT m Relations
-> (Relations -> CabalT m Relations) -> CabalT m Relations
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Relations -> CabalT m Relations
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Relations -> CabalT m Relations)
-> (Relations -> Relations) -> Relations -> CabalT m Relations
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relations -> Relations
finalizeRelations
Relations
depsIndep <- PackageDescription -> CabalT m Relations
forall (m :: * -> *).
MonadIO m =>
PackageDescription -> CabalT m Relations
debianBuildDepsIndep PackageDescription
pkgDesc CabalT m Relations
-> (Relations -> CabalT m Relations) -> CabalT m Relations
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Relations -> CabalT m Relations
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Relations -> CabalT m Relations)
-> (Relations -> Relations) -> Relations -> CabalT m Relations
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relations -> Relations
finalizeRelations
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Relations -> Identity Relations)
-> DebInfo -> Identity DebInfo)
-> (Relations -> Identity Relations)
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Relations -> Identity Relations)
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Relations -> Identity Relations)
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Relations -> Identity Relations)
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription Relations
S.buildDepends) ((Relations -> Identity Relations)
-> CabalInfo -> Identity CabalInfo)
-> Relations -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Relations
deps
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Relations -> Identity Relations)
-> DebInfo -> Identity DebInfo)
-> (Relations -> Identity Relations)
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription -> Identity SourceDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Relations -> Identity Relations)
-> SourceDebDescription -> Identity SourceDebDescription)
-> (Relations -> Identity Relations)
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Relations -> Identity Relations)
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription Relations
S.buildDependsIndep) ((Relations -> Identity Relations)
-> CabalInfo -> Identity CabalInfo)
-> Relations -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Relations
depsIndep
filterRelations :: [BinPkgName] -> Relations -> Relations
filterRelations :: [BinPkgName] -> Relations -> Relations
filterRelations [BinPkgName]
badNames Relations
orRels =
([Relation] -> Bool) -> Relations -> Relations
forall a. (a -> Bool) -> [a] -> [a]
List.filter (Bool -> Bool
not (Bool -> Bool) -> ([Relation] -> Bool) -> [Relation] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Relation] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null) (([Relation] -> [Relation]) -> Relations -> Relations
forall a b. (a -> b) -> [a] -> [b]
List.map [Relation] -> [Relation]
filterOrRelation Relations
orRels)
where
filterOrRelation :: [Relation] -> [Relation]
filterOrRelation :: [Relation] -> [Relation]
filterOrRelation [Relation]
rels = (Relation -> Bool) -> [Relation] -> [Relation]
forall a. (a -> Bool) -> [a] -> [a]
List.filter (\ (Rel BinPkgName
name Maybe VersionReq
_ Maybe ArchitectureReq
_) -> Bool -> Bool
not (BinPkgName -> [BinPkgName] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem BinPkgName
name [BinPkgName]
badNames)) [Relation]
rels
cabalExecBinaryPackage :: Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage :: forall (m :: * -> *). Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage BinPkgName
b =
do ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe PackageType -> f (Maybe PackageType))
-> DebInfo -> f DebInfo)
-> (Maybe PackageType -> f (Maybe PackageType))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe PackageType -> f (Maybe PackageType))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe PackageType -> f (Maybe PackageType))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe PackageType -> f (Maybe PackageType))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe PackageType)
B.packageType) (forall {f :: * -> *}.
Functor f =>
(Maybe PackageType -> f (Maybe PackageType))
-> CabalInfo -> f CabalInfo)
-> Maybe PackageType -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= PackageType -> Maybe PackageType
forall a. a -> Maybe a
Just PackageType
B.Exec
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> DebInfo -> f DebInfo)
-> (Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe PackageArchitectures)
B.architecture) (forall {f :: * -> *}.
Functor f =>
(Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> CabalInfo -> f CabalInfo)
-> Maybe PackageArchitectures -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= PackageArchitectures -> Maybe PackageArchitectures
forall a. a -> Maybe a
Just PackageArchitectures
Any
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe Section -> f (Maybe Section)) -> DebInfo -> f DebInfo)
-> (Maybe Section -> f (Maybe Section))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe Section -> f (Maybe Section))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe Section -> f (Maybe Section))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Section -> f (Maybe Section))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe Section)
B.binarySection) (forall {f :: * -> *}.
Functor f =>
(Maybe Section -> f (Maybe Section)) -> CabalInfo -> f CabalInfo)
-> Maybe Section -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Section -> Maybe Section
forall a. a -> Maybe a
Just ([Char] -> Section
MainSection [Char]
"misc")
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe Text -> f (Maybe Text)) -> DebInfo -> f DebInfo)
-> (Maybe Text -> f (Maybe Text))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe Text -> f (Maybe Text))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe Text -> f (Maybe Text))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Text -> f (Maybe Text))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe Text)
B.description) (forall {f :: * -> *}.
Functor f =>
(Maybe Text -> f (Maybe Text)) -> CabalInfo -> f CabalInfo)
-> Maybe Text -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Text -> Maybe Text
forall a. a -> Maybe a
Just Text
desc
BinPkgName -> PackageType -> CabalT m ()
forall (m :: * -> *).
Monad m =>
BinPkgName -> PackageType -> CabalT m ()
binaryPackageRelations BinPkgName
b PackageType
B.Exec
where
binaryPackageRelations :: Monad m => BinPkgName -> B.PackageType -> CabalT m ()
binaryPackageRelations :: forall (m :: * -> *).
Monad m =>
BinPkgName -> PackageType -> CabalT m ()
binaryPackageRelations BinPkgName
b PackageType
typ = LensLike' (Zoomed (StateT DebInfo m) ()) CabalInfo DebInfo
-> StateT DebInfo m () -> StateT CabalInfo m ()
forall c.
LensLike' (Zoomed (StateT DebInfo m) c) CabalInfo DebInfo
-> StateT DebInfo m c -> StateT CabalInfo m c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike' (Zoomed (StateT DebInfo m) ()) CabalInfo DebInfo
Lens' CabalInfo DebInfo
A.debInfo (StateT DebInfo m () -> StateT CabalInfo m ())
-> StateT DebInfo m () -> StateT CabalInfo m ()
forall a b. (a -> b) -> a -> b
$ do
Relations
edds <- Getting Relations DebInfo Relations -> StateT DebInfo m Relations
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting Relations DebInfo Relations
Lens' DebInfo Relations
D.extraDevDeps
LensLike'
(Zoomed (StateT PackageRelations m) ()) DebInfo PackageRelations
-> StateT PackageRelations m () -> StateT DebInfo m ()
forall c.
LensLike'
(Zoomed (StateT PackageRelations m) c) DebInfo PackageRelations
-> StateT PackageRelations m c -> StateT DebInfo m c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom (BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription
-> Zoomed (StateT PackageRelations m) () BinaryDebDescription)
-> DebInfo -> Zoomed (StateT PackageRelations m) () DebInfo)
-> ((PackageRelations
-> Zoomed (StateT PackageRelations m) () PackageRelations)
-> BinaryDebDescription
-> Zoomed (StateT PackageRelations m) () BinaryDebDescription)
-> LensLike'
(Zoomed (StateT PackageRelations m) ()) DebInfo PackageRelations
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PackageRelations
-> Zoomed (StateT PackageRelations m) () PackageRelations)
-> BinaryDebDescription
-> Zoomed (StateT PackageRelations m) () BinaryDebDescription
Lens' BinaryDebDescription PackageRelations
B.relations) (StateT PackageRelations m () -> StateT DebInfo m ())
-> StateT PackageRelations m () -> StateT DebInfo m ()
forall a b. (a -> b) -> a -> b
$ do
Bool
-> StateT PackageRelations m () -> StateT PackageRelations m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (PackageType
typ PackageType -> PackageType -> Bool
forall a. Eq a => a -> a -> Bool
== PackageType
B.Development) (StateT PackageRelations m () -> StateT PackageRelations m ())
-> StateT PackageRelations m () -> StateT PackageRelations m ()
forall a b. (a -> b) -> a -> b
$ do
(Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations
Lens' PackageRelations Relations
B.depends ((Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations)
-> (Relations -> Relations) -> StateT PackageRelations m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Relations
edds Relations -> Relations -> Relations
forall a. [a] -> [a] -> [a]
++)
(Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations
Lens' PackageRelations Relations
B.depends ((Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations)
-> (Relations -> Relations) -> StateT PackageRelations m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> [Relation]
anyrel [Char]
"${shlibs:Depends}" [Relation] -> Relations -> Relations
forall a. a -> [a] -> [a]
: )
Bool
-> StateT PackageRelations m () -> StateT PackageRelations m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (PackageType
typ PackageType -> PackageType -> Bool
forall a. Eq a => a -> a -> Bool
== PackageType
B.Utilities) (StateT PackageRelations m () -> StateT PackageRelations m ())
-> StateT PackageRelations m () -> StateT PackageRelations m ()
forall a b. (a -> b) -> a -> b
$
(Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations
Lens' PackageRelations Relations
B.depends ((Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations)
-> (Relations -> Relations) -> StateT PackageRelations m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> [Relation]
anyrel [Char]
"${shlibs:Depends}" [Relation] -> Relations -> Relations
forall a. a -> [a] -> [a]
: )
(Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations
Lens' PackageRelations Relations
B.depends ((Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations)
-> (Relations -> Relations) -> StateT PackageRelations m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([[Char] -> [Relation]
anyrel [Char]
"${haskell:Depends}", [Char] -> [Relation]
anyrel [Char]
"${misc:Depends}"] Relations -> Relations -> Relations
forall a. [a] -> [a] -> [a]
++)
(Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations
Lens' PackageRelations Relations
B.recommends ((Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations)
-> (Relations -> Relations) -> StateT PackageRelations m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> [Relation]
anyrel [Char]
"${haskell:Recommends}" [Relation] -> Relations -> Relations
forall a. a -> [a] -> [a]
: )
(Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations
Lens' PackageRelations Relations
B.suggests ((Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations)
-> (Relations -> Relations) -> StateT PackageRelations m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> [Relation]
anyrel [Char]
"${haskell:Suggests}" [Relation] -> Relations -> Relations
forall a. a -> [a] -> [a]
:)
(Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations
Lens' PackageRelations Relations
B.conflicts ((Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations)
-> (Relations -> Relations) -> StateT PackageRelations m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> [Relation]
anyrel [Char]
"${haskell:Conflicts}" [Relation] -> Relations -> Relations
forall a. a -> [a] -> [a]
:)
(Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations
Lens' PackageRelations Relations
B.preDepends ((Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations)
-> Relations -> StateT PackageRelations m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= []
(Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations
Lens' PackageRelations Relations
B.breaks ((Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations)
-> Relations -> StateT PackageRelations m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= []
(Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations
Lens' PackageRelations Relations
B.builtUsing ((Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations)
-> Relations -> StateT PackageRelations m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= []
Bool
-> StateT PackageRelations m () -> StateT PackageRelations m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (PackageType
typ PackageType -> PackageType -> Bool
forall a. Eq a => a -> a -> Bool
== PackageType
B.Documentation) (StateT PackageRelations m () -> StateT PackageRelations m ())
-> StateT PackageRelations m () -> StateT PackageRelations m ()
forall a b. (a -> b) -> a -> b
$ (Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations
Lens' PackageRelations Relations
B.provides ((Relations -> Identity Relations)
-> PackageRelations -> Identity PackageRelations)
-> (Relations -> Relations) -> StateT PackageRelations m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> [Relation]
anyrel [Char]
"${haskell:Provides}" [Relation] -> Relations -> Relations
forall a. a -> [a] -> [a]
:)
librarySpecs :: (Monad m) => PackageDescription -> CompilerFlavor -> CabalT m ()
librarySpecs :: forall (m :: * -> *).
Monad m =>
PackageDescription -> CompilerFlavor -> CabalT m ()
librarySpecs PackageDescription
pkgDesc CompilerFlavor
hc =
do let dev :: Bool
dev = Maybe Library -> Bool
forall a. Maybe a -> Bool
isJust (PackageDescription -> Maybe Library
Cabal.library PackageDescription
pkgDesc)
Bool
doc <- StateT CabalInfo m CabalInfo
forall s (m :: * -> *). MonadState s m => m s
get StateT CabalInfo m CabalInfo
-> (CabalInfo -> StateT CabalInfo m Bool)
-> StateT CabalInfo m Bool
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Bool -> StateT CabalInfo m Bool
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> StateT CabalInfo m Bool)
-> (CabalInfo -> Bool) -> CabalInfo -> StateT CabalInfo m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Bool
not (Bool -> Bool) -> (CabalInfo -> Bool) -> CabalInfo -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting Bool CabalInfo Bool -> CabalInfo -> Bool
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view ((DebInfo -> Const Bool DebInfo)
-> CabalInfo -> Const Bool CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const Bool DebInfo)
-> CabalInfo -> Const Bool CabalInfo)
-> ((Bool -> Const Bool Bool) -> DebInfo -> Const Bool DebInfo)
-> Getting Bool CabalInfo Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Bool -> Const Bool Bool) -> DebInfo -> Const Bool DebInfo
Lens' DebInfo Bool
D.noDocumentationLibrary)
Bool
prof <- StateT CabalInfo m CabalInfo
forall s (m :: * -> *). MonadState s m => m s
get StateT CabalInfo m CabalInfo
-> (CabalInfo -> StateT CabalInfo m Bool)
-> StateT CabalInfo m Bool
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Bool -> StateT CabalInfo m Bool
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> StateT CabalInfo m Bool)
-> (CabalInfo -> Bool) -> CabalInfo -> StateT CabalInfo m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Bool
not (Bool -> Bool) -> (CabalInfo -> Bool) -> CabalInfo -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting Bool CabalInfo Bool -> CabalInfo -> Bool
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view ((DebInfo -> Const Bool DebInfo)
-> CabalInfo -> Const Bool CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const Bool DebInfo)
-> CabalInfo -> Const Bool CabalInfo)
-> ((Bool -> Const Bool Bool) -> DebInfo -> Const Bool DebInfo)
-> Getting Bool CabalInfo Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Bool -> Const Bool Bool) -> DebInfo -> Const Bool DebInfo
Lens' DebInfo Bool
D.noProfilingLibrary)
Bool -> CabalT m () -> CabalT m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
dev (PackageArchitectures
-> PackageType -> CompilerFlavor -> CabalT m ()
forall (m :: * -> *).
Monad m =>
PackageArchitectures
-> PackageType -> CompilerFlavor -> CabalT m ()
librarySpec PackageArchitectures
Any PackageType
B.Development CompilerFlavor
hc)
Bool -> CabalT m () -> CabalT m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
dev Bool -> Bool -> Bool
&& Bool
prof Bool -> Bool -> Bool
&& CompilerFlavor
hc CompilerFlavor -> CompilerFlavor -> Bool
forall a. Eq a => a -> a -> Bool
== CompilerFlavor
GHC) (PackageArchitectures
-> PackageType -> CompilerFlavor -> CabalT m ()
forall (m :: * -> *).
Monad m =>
PackageArchitectures
-> PackageType -> CompilerFlavor -> CabalT m ()
librarySpec PackageArchitectures
Any PackageType
B.Profiling CompilerFlavor
hc)
Bool -> CabalT m () -> CabalT m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
dev Bool -> Bool -> Bool
&& Bool
doc) (CompilerFlavor -> CabalT m ()
forall (m :: * -> *). Monad m => CompilerFlavor -> CabalT m ()
docSpecsParagraph CompilerFlavor
hc)
docSpecsParagraph :: (Monad m) => CompilerFlavor -> CabalT m ()
docSpecsParagraph :: forall (m :: * -> *). Monad m => CompilerFlavor -> CabalT m ()
docSpecsParagraph CompilerFlavor
hc =
do BinPkgName
b <- PackageType -> CompilerFlavor -> CabalT m BinPkgName
forall (m :: * -> *) name.
(Monad m, PkgName name) =>
PackageType -> CompilerFlavor -> CabalT m name
debianName PackageType
B.Documentation CompilerFlavor
hc
BinPkgName -> PackageType -> CabalT m ()
forall (m :: * -> *).
Monad m =>
BinPkgName -> PackageType -> CabalT m ()
binaryPackageRelations BinPkgName
b PackageType
B.Documentation
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe PackageType -> f (Maybe PackageType))
-> DebInfo -> f DebInfo)
-> (Maybe PackageType -> f (Maybe PackageType))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe PackageType -> f (Maybe PackageType))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe PackageType -> f (Maybe PackageType))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe PackageType -> f (Maybe PackageType))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe PackageType)
B.packageType) (forall {f :: * -> *}.
Functor f =>
(Maybe PackageType -> f (Maybe PackageType))
-> CabalInfo -> f CabalInfo)
-> Maybe PackageType -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= PackageType -> Maybe PackageType
forall a. a -> Maybe a
Just PackageType
B.Documentation
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe PackageType -> f (Maybe PackageType))
-> DebInfo -> f DebInfo)
-> (Maybe PackageType -> f (Maybe PackageType))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe PackageType -> f (Maybe PackageType))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe PackageType -> f (Maybe PackageType))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe PackageType -> f (Maybe PackageType))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe PackageType)
B.packageType) (forall {f :: * -> *}.
Functor f =>
(Maybe PackageType -> f (Maybe PackageType))
-> CabalInfo -> f CabalInfo)
-> Maybe PackageType -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= PackageType -> Maybe PackageType
forall a. a -> Maybe a
Just PackageType
B.Documentation
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Maybe PackageArchitectures
-> Identity (Maybe PackageArchitectures))
-> DebInfo -> Identity DebInfo)
-> (Maybe PackageArchitectures
-> Identity (Maybe PackageArchitectures))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> Identity BinaryDebDescription)
-> DebInfo -> Identity DebInfo)
-> ((Maybe PackageArchitectures
-> Identity (Maybe PackageArchitectures))
-> BinaryDebDescription -> Identity BinaryDebDescription)
-> (Maybe PackageArchitectures
-> Identity (Maybe PackageArchitectures))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe PackageArchitectures
-> Identity (Maybe PackageArchitectures))
-> BinaryDebDescription -> Identity BinaryDebDescription
Lens' BinaryDebDescription (Maybe PackageArchitectures)
B.architecture) ((Maybe PackageArchitectures
-> Identity (Maybe PackageArchitectures))
-> CabalInfo -> Identity CabalInfo)
-> Maybe PackageArchitectures -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= PackageArchitectures -> Maybe PackageArchitectures
forall a. a -> Maybe a
Just PackageArchitectures
All
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe Section -> f (Maybe Section)) -> DebInfo -> f DebInfo)
-> (Maybe Section -> f (Maybe Section))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe Section -> f (Maybe Section))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe Section -> f (Maybe Section))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Section -> f (Maybe Section))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe Section)
B.binarySection) (forall {f :: * -> *}.
Functor f =>
(Maybe Section -> f (Maybe Section)) -> CabalInfo -> f CabalInfo)
-> Maybe Section -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Section -> Maybe Section
forall a. a -> Maybe a
Just ([Char] -> Section
MainSection [Char]
"doc")
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe Text -> f (Maybe Text)) -> DebInfo -> f DebInfo)
-> (Maybe Text -> f (Maybe Text))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe Text -> f (Maybe Text))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe Text -> f (Maybe Text))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Text -> f (Maybe Text))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe Text)
B.description) (forall {f :: * -> *}.
Functor f =>
(Maybe Text -> f (Maybe Text)) -> CabalInfo -> f CabalInfo)
-> Maybe Text -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Text -> Maybe Text
forall a. a -> Maybe a
Just Text
desc
librarySpec :: (Monad m) => PackageArchitectures -> B.PackageType -> CompilerFlavor -> CabalT m ()
librarySpec :: forall (m :: * -> *).
Monad m =>
PackageArchitectures
-> PackageType -> CompilerFlavor -> CabalT m ()
librarySpec PackageArchitectures
arch PackageType
typ CompilerFlavor
hc =
do BinPkgName
b <- PackageType -> CompilerFlavor -> CabalT m BinPkgName
forall (m :: * -> *) name.
(Monad m, PkgName name) =>
PackageType -> CompilerFlavor -> CabalT m name
debianName PackageType
typ CompilerFlavor
hc
BinPkgName -> PackageType -> CabalT m ()
forall (m :: * -> *).
Monad m =>
BinPkgName -> PackageType -> CabalT m ()
binaryPackageRelations BinPkgName
b PackageType
typ
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe PackageType -> f (Maybe PackageType))
-> DebInfo -> f DebInfo)
-> (Maybe PackageType -> f (Maybe PackageType))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe PackageType -> f (Maybe PackageType))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe PackageType -> f (Maybe PackageType))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe PackageType -> f (Maybe PackageType))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe PackageType)
B.packageType) (forall {f :: * -> *}.
Functor f =>
(Maybe PackageType -> f (Maybe PackageType))
-> CabalInfo -> f CabalInfo)
-> Maybe PackageType -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= PackageType -> Maybe PackageType
forall a. a -> Maybe a
Just PackageType
typ
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe PackageType -> f (Maybe PackageType))
-> DebInfo -> f DebInfo)
-> (Maybe PackageType -> f (Maybe PackageType))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe PackageType -> f (Maybe PackageType))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe PackageType -> f (Maybe PackageType))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe PackageType -> f (Maybe PackageType))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe PackageType)
B.packageType) (forall {f :: * -> *}.
Functor f =>
(Maybe PackageType -> f (Maybe PackageType))
-> CabalInfo -> f CabalInfo)
-> Maybe PackageType -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= PackageType -> Maybe PackageType
forall a. a -> Maybe a
Just PackageType
typ
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> DebInfo -> f DebInfo)
-> (Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe PackageArchitectures)
B.architecture) (forall {f :: * -> *}.
Functor f =>
(Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> CabalInfo -> f CabalInfo)
-> Maybe PackageArchitectures -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= PackageArchitectures -> Maybe PackageArchitectures
forall a. a -> Maybe a
Just PackageArchitectures
arch
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe Text -> f (Maybe Text)) -> DebInfo -> f DebInfo)
-> (Maybe Text -> f (Maybe Text))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe Text -> f (Maybe Text))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe Text -> f (Maybe Text))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Text -> f (Maybe Text))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe Text)
B.description) (forall {f :: * -> *}.
Functor f =>
(Maybe Text -> f (Maybe Text)) -> CabalInfo -> f CabalInfo)
-> Maybe Text -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Text -> Maybe Text
forall a. a -> Maybe a
Just Text
desc
desc :: Text
desc :: Text
desc = Text -> [Text] -> Text
Text.intercalate Text
"\n "
[Text
"${haskell:ShortDescription}${haskell:ShortBlurb}",
Text
"${haskell:LongDescription}",
Text
".",
Text
"${haskell:Blurb}"]
makeUtilsPackage :: forall m. (Monad m) => PackageDescription -> CompilerFlavor -> CabalT m ()
makeUtilsPackage :: forall (m :: * -> *).
Monad m =>
PackageDescription -> CompilerFlavor -> CabalT m ()
makeUtilsPackage PackageDescription
pkgDesc CompilerFlavor
hc =
do
Map BinPkgName (Set [Char])
installedDataMap <- (Atom
-> Map BinPkgName (Set [Char]) -> Map BinPkgName (Set [Char]))
-> Map BinPkgName (Set [Char])
-> Set Atom
-> Map BinPkgName (Set [Char])
forall a b. (a -> b -> b) -> b -> Set a -> b
Set.fold (\ Atom
x Map BinPkgName (Set [Char])
r ->
case Atom
x of
D.Install BinPkgName
b [Char]
src [Char]
_ -> (Set [Char] -> Set [Char] -> Set [Char])
-> BinPkgName
-> Set [Char]
-> Map BinPkgName (Set [Char])
-> Map BinPkgName (Set [Char])
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith Set [Char] -> Set [Char] -> Set [Char]
forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b ([Char] -> Set [Char]
forall a. a -> Set a
singleton [Char]
src) Map BinPkgName (Set [Char])
r
D.InstallTo BinPkgName
b [Char]
src [Char]
_ -> (Set [Char] -> Set [Char] -> Set [Char])
-> BinPkgName
-> Set [Char]
-> Map BinPkgName (Set [Char])
-> Map BinPkgName (Set [Char])
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith Set [Char] -> Set [Char] -> Set [Char]
forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b ([Char] -> Set [Char]
forall a. a -> Set a
singleton [Char]
src) Map BinPkgName (Set [Char])
r
D.InstallData BinPkgName
b [Char]
src [Char]
_ -> (Set [Char] -> Set [Char] -> Set [Char])
-> BinPkgName
-> Set [Char]
-> Map BinPkgName (Set [Char])
-> Map BinPkgName (Set [Char])
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith Set [Char] -> Set [Char] -> Set [Char]
forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b ([Char] -> Set [Char]
forall a. a -> Set a
singleton [Char]
src) Map BinPkgName (Set [Char])
r
Atom
_ -> Map BinPkgName (Set [Char])
r) Map BinPkgName (Set [Char])
forall a. Monoid a => a
mempty (Set Atom -> Map BinPkgName (Set [Char]))
-> StateT CabalInfo m (Set Atom)
-> StateT CabalInfo m (Map BinPkgName (Set [Char]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Getting (Set Atom) CabalInfo (Set Atom)
-> StateT CabalInfo m (Set Atom)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo)
-> ((Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo)
-> Getting (Set Atom) CabalInfo (Set Atom)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) :: CabalT m (Map BinPkgName (Set FilePath))
Map BinPkgName (Set [Char])
installedExecMap <- (Atom
-> Map BinPkgName (Set [Char]) -> Map BinPkgName (Set [Char]))
-> Map BinPkgName (Set [Char])
-> Set Atom
-> Map BinPkgName (Set [Char])
forall a b. (a -> b -> b) -> b -> Set a -> b
Set.fold (\ Atom
x Map BinPkgName (Set [Char])
r ->
case Atom
x of
D.InstallCabalExec BinPkgName
b [Char]
name [Char]
_ -> (Set [Char] -> Set [Char] -> Set [Char])
-> BinPkgName
-> Set [Char]
-> Map BinPkgName (Set [Char])
-> Map BinPkgName (Set [Char])
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith Set [Char] -> Set [Char] -> Set [Char]
forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b ([Char] -> Set [Char]
forall a. a -> Set a
singleton [Char]
name) Map BinPkgName (Set [Char])
r
D.InstallCabalExecTo BinPkgName
b [Char]
name [Char]
_ -> (Set [Char] -> Set [Char] -> Set [Char])
-> BinPkgName
-> Set [Char]
-> Map BinPkgName (Set [Char])
-> Map BinPkgName (Set [Char])
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith Set [Char] -> Set [Char] -> Set [Char]
forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b ([Char] -> Set [Char]
forall a. a -> Set a
singleton [Char]
name) Map BinPkgName (Set [Char])
r
Atom
_ -> Map BinPkgName (Set [Char])
r) Map BinPkgName (Set [Char])
forall a. Monoid a => a
mempty (Set Atom -> Map BinPkgName (Set [Char]))
-> StateT CabalInfo m (Set Atom)
-> StateT CabalInfo m (Map BinPkgName (Set [Char]))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Getting (Set Atom) CabalInfo (Set Atom)
-> StateT CabalInfo m (Set Atom)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo)
-> ((Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo)
-> Getting (Set Atom) CabalInfo (Set Atom)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) :: CabalT m (Map BinPkgName (Set String))
Set [Char]
insExecPkg <- Getting
(Map BinPkgName InstallFile) CabalInfo (Map BinPkgName InstallFile)
-> StateT CabalInfo m (Map BinPkgName InstallFile)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Map BinPkgName InstallFile) DebInfo)
-> CabalInfo -> Const (Map BinPkgName InstallFile) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Map BinPkgName InstallFile) DebInfo)
-> CabalInfo -> Const (Map BinPkgName InstallFile) CabalInfo)
-> ((Map BinPkgName InstallFile
-> Const (Map BinPkgName InstallFile) (Map BinPkgName InstallFile))
-> DebInfo -> Const (Map BinPkgName InstallFile) DebInfo)
-> Getting
(Map BinPkgName InstallFile) CabalInfo (Map BinPkgName InstallFile)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map BinPkgName InstallFile
-> Const (Map BinPkgName InstallFile) (Map BinPkgName InstallFile))
-> DebInfo -> Const (Map BinPkgName InstallFile) DebInfo
Lens' DebInfo (Map BinPkgName InstallFile)
D.executable) StateT CabalInfo m (Map BinPkgName InstallFile)
-> (Map BinPkgName InstallFile -> StateT CabalInfo m (Set [Char]))
-> StateT CabalInfo m (Set [Char])
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Set [Char] -> StateT CabalInfo m (Set [Char])
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Set [Char] -> StateT CabalInfo m (Set [Char]))
-> (Map BinPkgName InstallFile -> Set [Char])
-> Map BinPkgName InstallFile
-> StateT CabalInfo m (Set [Char])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (InstallFile -> [Char]) -> Set InstallFile -> Set [Char]
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map InstallFile -> [Char]
ename (Set InstallFile -> Set [Char])
-> (Map BinPkgName InstallFile -> Set InstallFile)
-> Map BinPkgName InstallFile
-> Set [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [InstallFile] -> Set InstallFile
forall a. Ord a => [a] -> Set a
Set.fromList ([InstallFile] -> Set InstallFile)
-> (Map BinPkgName InstallFile -> [InstallFile])
-> Map BinPkgName InstallFile
-> Set InstallFile
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map BinPkgName InstallFile -> [InstallFile]
forall k a. Map k a -> [a]
elems
let installedData :: Set (FilePath, FilePath)
installedData :: Set ([Char], [Char])
installedData = ([Char] -> ([Char], [Char])) -> Set [Char] -> Set ([Char], [Char])
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\ [Char]
a -> ([Char]
a, [Char]
a)) (Set [Char] -> Set ([Char], [Char]))
-> Set [Char] -> Set ([Char], [Char])
forall a b. (a -> b) -> a -> b
$ [Set [Char]] -> Set [Char]
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions (Map BinPkgName (Set [Char]) -> [Set [Char]]
forall k a. Map k a -> [a]
Map.elems Map BinPkgName (Set [Char])
installedDataMap)
installedExec :: Set String
installedExec :: Set [Char]
installedExec = [Set [Char]] -> Set [Char]
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions (Map BinPkgName (Set [Char]) -> [Set [Char]]
forall k a. Map k a -> [a]
Map.elems Map BinPkgName (Set [Char])
installedExecMap)
[Char]
prefixPath <- CabalT m [Char]
forall (m :: * -> *). Monad m => CabalT m [Char]
dataTop
let dataFilePaths :: Set ([Char], [Char])
dataFilePaths = [([Char], [Char])] -> Set ([Char], [Char])
forall a. Ord a => [a] -> Set a
Set.fromList ([[Char]] -> [[Char]] -> [([Char], [Char])]
forall a b. [a] -> [b] -> [(a, b)]
zip (([Char] -> [Char]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
List.map ([Char]
prefixPath [Char] -> [Char] -> [Char]
</>) (PackageDescription -> [[Char]]
Cabal.dataFiles PackageDescription
pkgDesc)) (PackageDescription -> [[Char]]
Cabal.dataFiles PackageDescription
pkgDesc)) :: Set (FilePath, FilePath)
execFilePaths :: Set FilePath
execFilePaths :: Set [Char]
execFilePaths = (Executable -> [Char]) -> Set Executable -> Set [Char]
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (UnqualComponentName -> [Char]
unUnqualComponentName (UnqualComponentName -> [Char])
-> (Executable -> UnqualComponentName) -> Executable -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Executable -> UnqualComponentName
Cabal.exeName) ((Executable -> Bool) -> Set Executable -> Set Executable
forall a. (a -> Bool) -> Set a -> Set a
Set.filter (BuildInfo -> Bool
Cabal.buildable (BuildInfo -> Bool)
-> (Executable -> BuildInfo) -> Executable -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Executable -> BuildInfo
Cabal.buildInfo) ([Executable] -> Set Executable
forall a. Ord a => [a] -> Set a
Set.fromList (PackageDescription -> [Executable]
Cabal.executables PackageDescription
pkgDesc))) :: Set FilePath
let availableData :: Set ([Char], [Char])
availableData = Set ([Char], [Char])
-> Set ([Char], [Char]) -> Set ([Char], [Char])
forall a. Ord a => Set a -> Set a -> Set a
Set.union Set ([Char], [Char])
installedData Set ([Char], [Char])
dataFilePaths
availableExec :: Set [Char]
availableExec = Set [Char] -> Set [Char] -> Set [Char]
forall a. Ord a => Set a -> Set a -> Set a
Set.union Set [Char]
installedExec Set [Char]
execFilePaths
Getting (Maybe [Char]) CabalInfo (Maybe [Char])
-> StateT CabalInfo m (Maybe [Char])
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe [Char]) DebInfo)
-> CabalInfo -> Const (Maybe [Char]) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe [Char]) DebInfo)
-> CabalInfo -> Const (Maybe [Char]) CabalInfo)
-> ((Maybe [Char] -> Const (Maybe [Char]) (Maybe [Char]))
-> DebInfo -> Const (Maybe [Char]) DebInfo)
-> Getting (Maybe [Char]) CabalInfo (Maybe [Char])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe [Char] -> Const (Maybe [Char]) (Maybe [Char]))
-> DebInfo -> Const (Maybe [Char]) DebInfo
Lens' DebInfo (Maybe [Char])
D.utilsPackageNameBase) StateT CabalInfo m (Maybe [Char])
-> (Maybe [Char] -> CabalT m ()) -> CabalT m ()
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ Maybe [Char]
name ->
case Maybe [Char]
name of
Maybe [Char]
Nothing -> PackageType -> CompilerFlavor -> CabalT m BinPkgName
forall (m :: * -> *) name.
(Monad m, PkgName name) =>
PackageType -> CompilerFlavor -> CabalT m name
debianName PackageType
B.Utilities CompilerFlavor
hc CabalT m BinPkgName -> (BinPkgName -> CabalT m ()) -> CabalT m ()
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ (BinPkgName [Char]
name') -> ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Maybe [Char] -> Identity (Maybe [Char]))
-> DebInfo -> Identity DebInfo)
-> (Maybe [Char] -> Identity (Maybe [Char]))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe [Char] -> Identity (Maybe [Char]))
-> DebInfo -> Identity DebInfo
Lens' DebInfo (Maybe [Char])
D.utilsPackageNameBase) ((Maybe [Char] -> Identity (Maybe [Char]))
-> CabalInfo -> Identity CabalInfo)
-> Maybe [Char] -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
name'
Maybe [Char]
_ -> () -> CabalT m ()
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
BinPkgName
b <- PackageType -> CompilerFlavor -> CabalT m BinPkgName
forall (m :: * -> *) name.
(Monad m, PkgName name) =>
PackageType -> CompilerFlavor -> CabalT m name
debianName PackageType
B.Utilities CompilerFlavor
hc
let installedDataOther :: Set ([Char], [Char])
installedDataOther = ([Char] -> ([Char], [Char])) -> Set [Char] -> Set ([Char], [Char])
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\ [Char]
a -> ([Char]
a, [Char]
a)) (Set [Char] -> Set ([Char], [Char]))
-> Set [Char] -> Set ([Char], [Char])
forall a b. (a -> b) -> a -> b
$ [Set [Char]] -> Set [Char]
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions ([Set [Char]] -> Set [Char]) -> [Set [Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ Map BinPkgName (Set [Char]) -> [Set [Char]]
forall k a. Map k a -> [a]
Map.elems (Map BinPkgName (Set [Char]) -> [Set [Char]])
-> Map BinPkgName (Set [Char]) -> [Set [Char]]
forall a b. (a -> b) -> a -> b
$ BinPkgName
-> Map BinPkgName (Set [Char]) -> Map BinPkgName (Set [Char])
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete BinPkgName
b Map BinPkgName (Set [Char])
installedDataMap
installedExecOther :: Set [Char]
installedExecOther = Set [Char] -> Set [Char] -> Set [Char]
forall a. Ord a => Set a -> Set a -> Set a
Set.union Set [Char]
insExecPkg (Set [Char] -> Set [Char]) -> Set [Char] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ [Set [Char]] -> Set [Char]
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions ([Set [Char]] -> Set [Char]) -> [Set [Char]] -> Set [Char]
forall a b. (a -> b) -> a -> b
$ Map BinPkgName (Set [Char]) -> [Set [Char]]
forall k a. Map k a -> [a]
Map.elems (Map BinPkgName (Set [Char]) -> [Set [Char]])
-> Map BinPkgName (Set [Char]) -> [Set [Char]]
forall a b. (a -> b) -> a -> b
$ BinPkgName
-> Map BinPkgName (Set [Char]) -> Map BinPkgName (Set [Char])
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete BinPkgName
b Map BinPkgName (Set [Char])
installedExecMap
let utilsData :: Set ([Char], [Char])
utilsData = Set ([Char], [Char])
-> Set ([Char], [Char]) -> Set ([Char], [Char])
forall a. Ord a => Set a -> Set a -> Set a
Set.difference Set ([Char], [Char])
availableData Set ([Char], [Char])
installedDataOther
utilsExec :: Set [Char]
utilsExec = Set [Char] -> Set [Char] -> Set [Char]
forall a. Ord a => Set a -> Set a -> Set a
Set.difference Set [Char]
availableExec Set [Char]
installedExecOther
let utilsDataMissing :: Set ([Char], [Char])
utilsDataMissing = Set ([Char], [Char])
-> Set ([Char], [Char]) -> Set ([Char], [Char])
forall a. Ord a => Set a -> Set a -> Set a
Set.difference Set ([Char], [Char])
utilsData Set ([Char], [Char])
installedData
utilsExecMissing :: Set [Char]
utilsExecMissing = Set [Char] -> Set [Char] -> Set [Char]
forall a. Ord a => Set a -> Set a -> Set a
Set.difference Set [Char]
utilsExec Set [Char]
installedExec
Bool -> CabalT m () -> CabalT m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not (Set ([Char], [Char]) -> Bool
forall a. Set a -> Bool
Set.null Set ([Char], [Char])
utilsData Bool -> Bool -> Bool
&& Set [Char] -> Bool
forall a. Set a -> Bool
Set.null Set [Char]
utilsExec)) (CabalT m () -> CabalT m ()) -> CabalT m () -> CabalT m ()
forall a b. (a -> b) -> a -> b
$ do
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe Text -> f (Maybe Text)) -> DebInfo -> f DebInfo)
-> (Maybe Text -> f (Maybe Text))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe Text -> f (Maybe Text))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe Text -> f (Maybe Text))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Text -> f (Maybe Text))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe Text)
B.description) (forall {f :: * -> *}.
Functor f =>
(Maybe Text -> f (Maybe Text)) -> CabalInfo -> f CabalInfo)
-> Maybe Text -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Text -> Maybe Text
forall a. a -> Maybe a
Just Text
desc
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Text -> Identity (Set Text))
-> DebInfo -> Identity DebInfo)
-> (Set Text -> Identity (Set Text))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Text -> Identity (Set Text)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Text)
D.rulesFragments) ((Set Text -> Identity (Set Text))
-> CabalInfo -> Identity CabalInfo)
-> (Set Text -> Set Text) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= Text -> Set Text -> Set Text
forall a. Ord a => a -> Set a -> Set a
Set.insert ([Char] -> Text
pack ([Char]
"build" [Char] -> [Char] -> [Char]
</> BinPkgName -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
":: build-ghc-stamp\n"))
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> DebInfo -> f DebInfo)
-> (Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe PackageArchitectures)
B.architecture) (forall {f :: * -> *}.
Functor f =>
(Maybe PackageArchitectures -> f (Maybe PackageArchitectures))
-> CabalInfo -> f CabalInfo)
-> Maybe PackageArchitectures -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= PackageArchitectures -> Maybe PackageArchitectures
forall a. a -> Maybe a
Just (if Set [Char] -> Bool
forall a. Set a -> Bool
Set.null Set [Char]
utilsExec then PackageArchitectures
All else PackageArchitectures
Any)
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe Section -> f (Maybe Section)) -> DebInfo -> f DebInfo)
-> (Maybe Section -> f (Maybe Section))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b ((BinaryDebDescription -> f BinaryDebDescription)
-> DebInfo -> f DebInfo)
-> ((Maybe Section -> f (Maybe Section))
-> BinaryDebDescription -> f BinaryDebDescription)
-> (Maybe Section -> f (Maybe Section))
-> DebInfo
-> f DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Section -> f (Maybe Section))
-> BinaryDebDescription -> f BinaryDebDescription
Lens' BinaryDebDescription (Maybe Section)
B.binarySection) (forall {f :: * -> *}.
Functor f =>
(Maybe Section -> f (Maybe Section)) -> CabalInfo -> f CabalInfo)
-> Maybe Section -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Section -> Maybe Section
forall a. a -> Maybe a
Just ([Char] -> Section
MainSection [Char]
"misc")
BinPkgName -> PackageType -> CabalT m ()
forall (m :: * -> *).
Monad m =>
BinPkgName -> PackageType -> CabalT m ()
binaryPackageRelations BinPkgName
b PackageType
B.Utilities
(([Char], [Char]) -> CabalT m ())
-> Set ([Char], [Char]) -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\ ([Char]
foo, [Char]
bar) -> ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Atom -> Identity (Set Atom))
-> DebInfo -> Identity DebInfo)
-> (Set Atom -> Identity (Set Atom))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Identity (Set Atom)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) ((Set Atom -> Identity (Set Atom))
-> CabalInfo -> Identity CabalInfo)
-> (Set Atom -> Set Atom) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Atom -> Set Atom -> Set Atom
forall a. Ord a => a -> Set a -> Set a
Set.insert (Atom -> Set Atom -> Set Atom) -> Atom -> Set Atom -> Set Atom
forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.InstallData BinPkgName
b [Char]
foo [Char]
bar)) Set ([Char], [Char])
utilsDataMissing
([Char] -> CabalT m ()) -> Set [Char] -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\ [Char]
name -> ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Atom -> Identity (Set Atom))
-> DebInfo -> Identity DebInfo)
-> (Set Atom -> Identity (Set Atom))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Identity (Set Atom)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) ((Set Atom -> Identity (Set Atom))
-> CabalInfo -> Identity CabalInfo)
-> (Set Atom -> Set Atom) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Atom -> Set Atom -> Set Atom
forall a. Ord a => a -> Set a -> Set a
Set.insert (Atom -> Set Atom -> Set Atom) -> Atom -> Set Atom -> Set Atom
forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.InstallCabalExec BinPkgName
b [Char]
name [Char]
"usr/bin")) Set [Char]
utilsExecMissing
where
ename :: InstallFile -> [Char]
ename InstallFile
i =
case InstallFile -> Maybe [Char]
D.sourceDir InstallFile
i of
Maybe [Char]
Nothing -> InstallFile -> [Char]
D.execName InstallFile
i
Just [Char]
s -> [Char]
s [Char] -> [Char] -> [Char]
</> InstallFile -> [Char]
D.execName InstallFile
i
expandAtoms :: Monad m => CabalT m () -> CabalT m ()
expandAtoms :: forall (m :: * -> *). Monad m => CabalT m () -> CabalT m ()
expandAtoms CabalT m ()
goodies =
do CompilerFlavor
hc <- Getting CompilerFlavor CabalInfo CompilerFlavor
-> StateT CabalInfo m CompilerFlavor
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const CompilerFlavor DebInfo)
-> CabalInfo -> Const CompilerFlavor CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const CompilerFlavor DebInfo)
-> CabalInfo -> Const CompilerFlavor CabalInfo)
-> ((CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> DebInfo -> Const CompilerFlavor DebInfo)
-> Getting CompilerFlavor CabalInfo CompilerFlavor
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Flags -> Const CompilerFlavor Flags)
-> DebInfo -> Const CompilerFlavor DebInfo
Lens' DebInfo Flags
D.flags ((Flags -> Const CompilerFlavor Flags)
-> DebInfo -> Const CompilerFlavor DebInfo)
-> ((CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> Flags -> Const CompilerFlavor Flags)
-> (CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> DebInfo
-> Const CompilerFlavor DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> Flags -> Const CompilerFlavor Flags
Lens' Flags CompilerFlavor
compilerFlavor)
case CompilerFlavor
hc of
CompilerFlavor
GHC -> ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> DebInfo -> Identity DebInfo)
-> (Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Flags -> Identity Flags) -> DebInfo -> Identity DebInfo
Lens' DebInfo Flags
D.flags ((Flags -> Identity Flags) -> DebInfo -> Identity DebInfo)
-> ((Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> Flags -> Identity Flags)
-> (Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> Flags -> Identity Flags
Lens' Flags (Set (FlagName, Bool))
cabalFlagAssignments) ((Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> CabalInfo -> Identity CabalInfo)
-> (Set (FlagName, Bool) -> Set (FlagName, Bool)) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Set (FlagName, Bool)
-> Set (FlagName, Bool) -> Set (FlagName, Bool)
forall a. Ord a => Set a -> Set a -> Set a
Set.union ([(FlagName, Bool)] -> Set (FlagName, Bool)
forall a. Ord a => [a] -> Set a
Set.fromList ([Char] -> [(FlagName, Bool)]
flagList [Char]
"--ghc")))
CompilerFlavor
GHCJS -> ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> DebInfo -> Identity DebInfo)
-> (Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Flags -> Identity Flags) -> DebInfo -> Identity DebInfo
Lens' DebInfo Flags
D.flags ((Flags -> Identity Flags) -> DebInfo -> Identity DebInfo)
-> ((Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> Flags -> Identity Flags)
-> (Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> Flags -> Identity Flags
Lens' Flags (Set (FlagName, Bool))
cabalFlagAssignments) ((Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> CabalInfo -> Identity CabalInfo)
-> (Set (FlagName, Bool) -> Set (FlagName, Bool)) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Set (FlagName, Bool)
-> Set (FlagName, Bool) -> Set (FlagName, Bool)
forall a. Ord a => Set a -> Set a -> Set a
Set.union ([(FlagName, Bool)] -> Set (FlagName, Bool)
forall a. Ord a => [a] -> Set a
Set.fromList ([Char] -> [(FlagName, Bool)]
flagList [Char]
"--ghcjs")))
CompilerFlavor
x -> [Char] -> CabalT m ()
forall a. HasCallStack => [Char] -> a
error ([Char] -> CabalT m ()) -> [Char] -> CabalT m ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Sorry, compiler not supported: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ CompilerFlavor -> [Char]
forall a. Show a => a -> [Char]
show CompilerFlavor
x
[Char]
builddir <- Getting (Maybe [Char]) CabalInfo (Maybe [Char])
-> StateT CabalInfo m (Maybe [Char])
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe [Char]) DebInfo)
-> CabalInfo -> Const (Maybe [Char]) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe [Char]) DebInfo)
-> CabalInfo -> Const (Maybe [Char]) CabalInfo)
-> ((Maybe [Char] -> Const (Maybe [Char]) (Maybe [Char]))
-> DebInfo -> Const (Maybe [Char]) DebInfo)
-> Getting (Maybe [Char]) CabalInfo (Maybe [Char])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe [Char] -> Const (Maybe [Char]) (Maybe [Char]))
-> DebInfo -> Const (Maybe [Char]) DebInfo
Lens' DebInfo (Maybe [Char])
D.buildDir) StateT CabalInfo m (Maybe [Char])
-> (Maybe [Char] -> StateT CabalInfo m [Char])
-> StateT CabalInfo m [Char]
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [Char] -> StateT CabalInfo m [Char]
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Char] -> StateT CabalInfo m [Char])
-> (Maybe [Char] -> [Char])
-> Maybe [Char]
-> StateT CabalInfo m [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Maybe [Char] -> [Char]
forall a. a -> Maybe a -> a
fromMaybe (case CompilerFlavor
hc of
CompilerFlavor
GHC -> [Char]
"dist-ghc/build"
CompilerFlavor
GHCJS -> [Char]
"dist-ghcjs/build"
CompilerFlavor
_ -> [Char] -> [Char]
forall a. HasCallStack => [Char] -> a
error ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ [Char]
"Unexpected compiler: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ CompilerFlavor -> [Char]
forall a. Show a => a -> [Char]
show CompilerFlavor
hc)
[Char]
dDest <- StateT CabalInfo m [Char]
forall (m :: * -> *). Monad m => CabalT m [Char]
dataDest
CabalT m ()
forall (m :: * -> *). Monad m => CabalT m ()
expandApacheSites
[Char] -> CabalT m ()
forall (m :: * -> *). Monad m => [Char] -> CabalT m ()
expandInstallCabalExecs [Char]
builddir
[Char] -> CabalT m ()
forall (m :: * -> *). Monad m => [Char] -> CabalT m ()
expandInstallCabalExecTo [Char]
builddir
[Char] -> CabalT m ()
forall (m :: * -> *). Monad m => [Char] -> CabalT m ()
expandInstallData [Char]
dDest
CabalT m ()
forall (m :: * -> *). Monad m => CabalT m ()
expandInstallTo
CabalT m ()
forall (m :: * -> *). Monad m => CabalT m ()
expandFile
#if 1
CabalT m ()
goodies
#else
expandWebsite
expandServer
expandBackups
#endif
CabalT m ()
forall (m :: * -> *). Monad m => CabalT m ()
expandExecutable
where
expandApacheSites :: Monad m => CabalT m ()
expandApacheSites :: forall (m :: * -> *). Monad m => CabalT m ()
expandApacheSites =
do Map BinPkgName ([Char], [Char], Text)
mp <- StateT CabalInfo m CabalInfo
forall s (m :: * -> *). MonadState s m => m s
get StateT CabalInfo m CabalInfo
-> (CabalInfo
-> StateT CabalInfo m (Map BinPkgName ([Char], [Char], Text)))
-> StateT CabalInfo m (Map BinPkgName ([Char], [Char], Text))
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Map BinPkgName ([Char], [Char], Text)
-> StateT CabalInfo m (Map BinPkgName ([Char], [Char], Text))
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Map BinPkgName ([Char], [Char], Text)
-> StateT CabalInfo m (Map BinPkgName ([Char], [Char], Text)))
-> (CabalInfo -> Map BinPkgName ([Char], [Char], Text))
-> CabalInfo
-> StateT CabalInfo m (Map BinPkgName ([Char], [Char], Text))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting
(Map BinPkgName ([Char], [Char], Text))
CabalInfo
(Map BinPkgName ([Char], [Char], Text))
-> CabalInfo -> Map BinPkgName ([Char], [Char], Text)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view ((DebInfo -> Const (Map BinPkgName ([Char], [Char], Text)) DebInfo)
-> CabalInfo
-> Const (Map BinPkgName ([Char], [Char], Text)) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Map BinPkgName ([Char], [Char], Text)) DebInfo)
-> CabalInfo
-> Const (Map BinPkgName ([Char], [Char], Text)) CabalInfo)
-> ((Map BinPkgName ([Char], [Char], Text)
-> Const
(Map BinPkgName ([Char], [Char], Text))
(Map BinPkgName ([Char], [Char], Text)))
-> DebInfo
-> Const (Map BinPkgName ([Char], [Char], Text)) DebInfo)
-> Getting
(Map BinPkgName ([Char], [Char], Text))
CabalInfo
(Map BinPkgName ([Char], [Char], Text))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map BinPkgName ([Char], [Char], Text)
-> Const
(Map BinPkgName ([Char], [Char], Text))
(Map BinPkgName ([Char], [Char], Text)))
-> DebInfo -> Const (Map BinPkgName ([Char], [Char], Text)) DebInfo
Lens' DebInfo (Map BinPkgName ([Char], [Char], Text))
D.apacheSite)
((BinPkgName, ([Char], [Char], Text)) -> CabalT m ())
-> [(BinPkgName, ([Char], [Char], Text))] -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ (BinPkgName, ([Char], [Char], Text)) -> CabalT m ()
forall {m :: * -> *}.
MonadState CabalInfo m =>
(BinPkgName, ([Char], [Char], Text)) -> m ()
expandApacheSite (Map BinPkgName ([Char], [Char], Text)
-> [(BinPkgName, ([Char], [Char], Text))]
forall k a. Map k a -> [(k, a)]
Map.toList Map BinPkgName ([Char], [Char], Text)
mp)
where
expandApacheSite :: (BinPkgName, ([Char], [Char], Text)) -> m ()
expandApacheSite (BinPkgName
b, ([Char]
dom, [Char]
log, Text
text)) =
do ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Atom -> Identity (Set Atom))
-> DebInfo -> Identity DebInfo)
-> (Set Atom -> Identity (Set Atom))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Identity (Set Atom)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) ((Set Atom -> Identity (Set Atom))
-> CabalInfo -> Identity CabalInfo)
-> (Set Atom -> Set Atom) -> m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Atom -> Set Atom -> Set Atom
forall a. Ord a => a -> Set a -> Set a
Set.insert (Atom -> Set Atom -> Set Atom) -> Atom -> Set Atom -> Set Atom
forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.Link BinPkgName
b ([Char]
"/etc/apache2/sites-available/" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
dom) ([Char]
"/etc/apache2/sites-enabled/" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
dom))
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Atom -> Identity (Set Atom))
-> DebInfo -> Identity DebInfo)
-> (Set Atom -> Identity (Set Atom))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Identity (Set Atom)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) ((Set Atom -> Identity (Set Atom))
-> CabalInfo -> Identity CabalInfo)
-> (Set Atom -> Set Atom) -> m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Atom -> Set Atom -> Set Atom
forall a. Ord a => a -> Set a -> Set a
Set.insert (Atom -> Set Atom -> Set Atom) -> Atom -> Set Atom -> Set Atom
forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> Atom
D.InstallDir BinPkgName
b [Char]
log)
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Atom -> Identity (Set Atom))
-> DebInfo -> Identity DebInfo)
-> (Set Atom -> Identity (Set Atom))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Identity (Set Atom)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) ((Set Atom -> Identity (Set Atom))
-> CabalInfo -> Identity CabalInfo)
-> (Set Atom -> Set Atom) -> m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Atom -> Set Atom -> Set Atom
forall a. Ord a => a -> Set a -> Set a
Set.insert (Atom -> Set Atom -> Set Atom) -> Atom -> Set Atom -> Set Atom
forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> Text -> Atom
D.File BinPkgName
b ([Char]
"/etc/apache2/sites-available" [Char] -> [Char] -> [Char]
</> [Char]
dom) Text
text)
expandInstallCabalExecs :: Monad m => FilePath -> CabalT m ()
expandInstallCabalExecs :: forall (m :: * -> *). Monad m => [Char] -> CabalT m ()
expandInstallCabalExecs [Char]
builddir = do
CompilerFlavor
hc <- Getting CompilerFlavor CabalInfo CompilerFlavor
-> StateT CabalInfo m CompilerFlavor
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const CompilerFlavor DebInfo)
-> CabalInfo -> Const CompilerFlavor CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const CompilerFlavor DebInfo)
-> CabalInfo -> Const CompilerFlavor CabalInfo)
-> ((CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> DebInfo -> Const CompilerFlavor DebInfo)
-> Getting CompilerFlavor CabalInfo CompilerFlavor
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Flags -> Const CompilerFlavor Flags)
-> DebInfo -> Const CompilerFlavor DebInfo
Lens' DebInfo Flags
D.flags ((Flags -> Const CompilerFlavor Flags)
-> DebInfo -> Const CompilerFlavor DebInfo)
-> ((CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> Flags -> Const CompilerFlavor Flags)
-> (CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> DebInfo
-> Const CompilerFlavor DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> Flags -> Const CompilerFlavor Flags
Lens' Flags CompilerFlavor
compilerFlavor)
Getting (Set Atom) CabalInfo (Set Atom)
-> StateT CabalInfo m (Set Atom)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo)
-> ((Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo)
-> Getting (Set Atom) CabalInfo (Set Atom)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) StateT CabalInfo m (Set Atom)
-> (Set Atom -> CabalT m ()) -> CabalT m ()
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Atom -> CabalT m ()) -> Set Atom -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (CompilerFlavor -> Atom -> CabalT m ()
forall (m :: * -> *).
Monad m =>
CompilerFlavor -> Atom -> CabalT m ()
doAtom CompilerFlavor
hc)
where
doAtom :: Monad m => CompilerFlavor -> D.Atom -> CabalT m ()
doAtom :: forall (m :: * -> *).
Monad m =>
CompilerFlavor -> Atom -> CabalT m ()
doAtom CompilerFlavor
GHC (D.InstallCabalExec BinPkgName
b [Char]
name [Char]
dest) = ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Atom -> Identity (Set Atom))
-> DebInfo -> Identity DebInfo)
-> (Set Atom -> Identity (Set Atom))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Identity (Set Atom)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) ((Set Atom -> Identity (Set Atom))
-> CabalInfo -> Identity CabalInfo)
-> (Set Atom -> Set Atom) -> StateT CabalInfo m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Atom -> Set Atom -> Set Atom
forall a. Ord a => a -> Set a -> Set a
Set.insert (Atom -> Set Atom -> Set Atom) -> Atom -> Set Atom -> Set Atom
forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.Install BinPkgName
b ([Char]
builddir [Char] -> [Char] -> [Char]
</> [Char]
name [Char] -> [Char] -> [Char]
</> [Char]
name) [Char]
dest)
doAtom CompilerFlavor
GHCJS (D.InstallCabalExec BinPkgName
b [Char]
name [Char]
dest) =
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Text -> Identity (Set Text))
-> DebInfo -> Identity DebInfo)
-> (Set Text -> Identity (Set Text))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Text -> Identity (Set Text)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Text)
D.rulesFragments) ((Set Text -> Identity (Set Text))
-> CabalInfo -> Identity CabalInfo)
-> (Set Text -> Set Text) -> StateT CabalInfo m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= Text -> Set Text -> Set Text
forall a. Ord a => a -> Set a -> Set a
Set.insert
([Text] -> Text
Text.unlines
[ [Char] -> Text
pack ([Char]
"binary-fixup" [Char] -> [Char] -> [Char]
</> BinPkgName -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"::"
, [Char] -> Text
pack ([Char]
"\t(cd " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
builddir [Char] -> [Char] -> [Char]
</> [Char]
name [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
" && find -L " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
name [Char] -> [Char] -> [Char]
<.> [Char]
"jsexe" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
" -type f) |\\\n" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<>
[Char]
"\t while read i; do install -Dp " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
builddir [Char] -> [Char] -> [Char]
</> [Char]
name [Char] -> [Char] -> [Char]
</> [Char]
"$$i debian" [Char] -> [Char] -> [Char]
</> BinPkgName -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b [Char] -> [Char] -> [Char]
</> [Char] -> [Char] -> [Char]
makeRelative [Char]
"/" [Char]
dest [Char] -> [Char] -> [Char]
</> [Char]
"$$i; done\n") ])
doAtom CompilerFlavor
_ Atom
_ = () -> StateT CabalInfo m ()
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
expandInstallCabalExecTo :: Monad m => FilePath -> CabalT m ()
expandInstallCabalExecTo :: forall (m :: * -> *). Monad m => [Char] -> CabalT m ()
expandInstallCabalExecTo [Char]
builddir = do
CompilerFlavor
hc <- Getting CompilerFlavor CabalInfo CompilerFlavor
-> StateT CabalInfo m CompilerFlavor
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const CompilerFlavor DebInfo)
-> CabalInfo -> Const CompilerFlavor CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const CompilerFlavor DebInfo)
-> CabalInfo -> Const CompilerFlavor CabalInfo)
-> ((CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> DebInfo -> Const CompilerFlavor DebInfo)
-> Getting CompilerFlavor CabalInfo CompilerFlavor
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Flags -> Const CompilerFlavor Flags)
-> DebInfo -> Const CompilerFlavor DebInfo
Lens' DebInfo Flags
D.flags ((Flags -> Const CompilerFlavor Flags)
-> DebInfo -> Const CompilerFlavor DebInfo)
-> ((CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> Flags -> Const CompilerFlavor Flags)
-> (CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> DebInfo
-> Const CompilerFlavor DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> Flags -> Const CompilerFlavor Flags
Lens' Flags CompilerFlavor
compilerFlavor)
Getting (Set Atom) CabalInfo (Set Atom)
-> StateT CabalInfo m (Set Atom)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo)
-> ((Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo)
-> Getting (Set Atom) CabalInfo (Set Atom)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) StateT CabalInfo m (Set Atom)
-> (Set Atom -> CabalT m ()) -> CabalT m ()
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Atom -> CabalT m ()) -> Set Atom -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (CompilerFlavor -> Atom -> CabalT m ()
forall (m :: * -> *).
Monad m =>
CompilerFlavor -> Atom -> CabalT m ()
doAtom CompilerFlavor
hc)
where
doAtom :: Monad m => CompilerFlavor -> D.Atom -> CabalT m ()
doAtom :: forall (m :: * -> *).
Monad m =>
CompilerFlavor -> Atom -> CabalT m ()
doAtom CompilerFlavor
GHC (D.InstallCabalExecTo BinPkgName
b [Char]
name [Char]
dest) =
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Text -> Identity (Set Text))
-> DebInfo -> Identity DebInfo)
-> (Set Text -> Identity (Set Text))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Text -> Identity (Set Text)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Text)
D.rulesFragments) ((Set Text -> Identity (Set Text))
-> CabalInfo -> Identity CabalInfo)
-> (Set Text -> Set Text) -> StateT CabalInfo m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= Text -> Set Text -> Set Text
forall a. Ord a => a -> Set a -> Set a
Set.insert
([Text] -> Text
Text.unlines
[ [Char] -> Text
pack ([Char]
"binary-fixup" [Char] -> [Char] -> [Char]
</> BinPkgName -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"::"
, Text
"\tinstall -Dps " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack ([Char]
builddir [Char] -> [Char] -> [Char]
</> [Char]
name [Char] -> [Char] -> [Char]
</> [Char]
name) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" "
Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack ([Char]
"debian" [Char] -> [Char] -> [Char]
</> BinPkgName -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b [Char] -> [Char] -> [Char]
</> [Char] -> [Char] -> [Char]
makeRelative [Char]
"/" [Char]
dest) ])
doAtom CompilerFlavor
hc (D.InstallCabalExecTo BinPkgName
b [Char]
name [Char]
dest) = [Char] -> StateT CabalInfo m ()
forall a. HasCallStack => [Char] -> a
error ([Char] -> StateT CabalInfo m ())
-> [Char] -> StateT CabalInfo m ()
forall a b. (a -> b) -> a -> b
$ [Char]
"expandInstallCabalExecTo " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ CompilerFlavor -> [Char]
forall a. Show a => a -> [Char]
show CompilerFlavor
hc [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Atom -> [Char]
forall a. Show a => a -> [Char]
show (BinPkgName -> [Char] -> [Char] -> Atom
D.InstallCabalExecTo BinPkgName
b [Char]
name [Char]
dest)
doAtom CompilerFlavor
_ Atom
_ = () -> StateT CabalInfo m ()
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
expandInstallData :: Monad m => FilePath -> CabalT m ()
expandInstallData :: forall (m :: * -> *). Monad m => [Char] -> CabalT m ()
expandInstallData [Char]
dDest =
Getting (Set Atom) CabalInfo (Set Atom)
-> StateT CabalInfo m (Set Atom)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo)
-> ((Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo)
-> Getting (Set Atom) CabalInfo (Set Atom)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) StateT CabalInfo m (Set Atom)
-> (Set Atom -> StateT CabalInfo m ()) -> StateT CabalInfo m ()
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Atom -> StateT CabalInfo m ()) -> [Atom] -> StateT CabalInfo m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ Atom -> StateT CabalInfo m ()
forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom ([Atom] -> StateT CabalInfo m ())
-> (Set Atom -> [Atom]) -> Set Atom -> StateT CabalInfo m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set Atom -> [Atom]
forall a. Set a -> [a]
Set.toList
where
doAtom :: Monad m => D.Atom -> CabalT m ()
doAtom :: forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom (D.InstallData BinPkgName
b [Char]
src [Char]
dest) =
if [Char] -> [Char]
takeFileName [Char]
src [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char] -> [Char]
takeFileName [Char]
dest
then ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Atom -> Identity (Set Atom))
-> DebInfo -> Identity DebInfo)
-> (Set Atom -> Identity (Set Atom))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Identity (Set Atom)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) ((Set Atom -> Identity (Set Atom))
-> CabalInfo -> Identity CabalInfo)
-> (Set Atom -> Set Atom) -> StateT CabalInfo m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Atom -> Set Atom -> Set Atom
forall a. Ord a => a -> Set a -> Set a
Set.insert (Atom -> Set Atom -> Set Atom) -> Atom -> Set Atom -> Set Atom
forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.Install BinPkgName
b [Char]
src ([Char]
dDest [Char] -> [Char] -> [Char]
</> [Char] -> [Char] -> [Char]
makeRelative [Char]
"/" ([Char] -> [Char]
takeDirectory [Char]
dest)))
else ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Atom -> Identity (Set Atom))
-> DebInfo -> Identity DebInfo)
-> (Set Atom -> Identity (Set Atom))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Identity (Set Atom)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) ((Set Atom -> Identity (Set Atom))
-> CabalInfo -> Identity CabalInfo)
-> (Set Atom -> Set Atom) -> StateT CabalInfo m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Atom -> Set Atom -> Set Atom
forall a. Ord a => a -> Set a -> Set a
Set.insert (Atom -> Set Atom -> Set Atom) -> Atom -> Set Atom -> Set Atom
forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.InstallTo BinPkgName
b [Char]
src ([Char]
dDest [Char] -> [Char] -> [Char]
</> [Char] -> [Char] -> [Char]
makeRelative [Char]
"/" [Char]
dest))
doAtom Atom
_ = () -> StateT CabalInfo m ()
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
expandInstallTo :: Monad m => CabalT m ()
expandInstallTo :: forall (m :: * -> *). Monad m => CabalT m ()
expandInstallTo =
Getting (Set Atom) CabalInfo (Set Atom)
-> StateT CabalInfo m (Set Atom)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo)
-> ((Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo)
-> Getting (Set Atom) CabalInfo (Set Atom)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) StateT CabalInfo m (Set Atom)
-> (Set Atom -> StateT CabalInfo m ()) -> StateT CabalInfo m ()
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Atom -> StateT CabalInfo m ()) -> [Atom] -> StateT CabalInfo m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ Atom -> StateT CabalInfo m ()
forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom ([Atom] -> StateT CabalInfo m ())
-> (Set Atom -> [Atom]) -> Set Atom -> StateT CabalInfo m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set Atom -> [Atom]
forall a. Set a -> [a]
Set.toList
where
doAtom :: Monad m => D.Atom -> CabalT m ()
doAtom :: forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom (D.InstallTo BinPkgName
b [Char]
src [Char]
dest) =
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Text -> Identity (Set Text))
-> DebInfo -> Identity DebInfo)
-> (Set Text -> Identity (Set Text))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Text -> Identity (Set Text)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Text)
D.rulesFragments) ((Set Text -> Identity (Set Text))
-> CabalInfo -> Identity CabalInfo)
-> (Set Text -> Set Text) -> StateT CabalInfo m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= Text -> Set Text -> Set Text
forall a. Ord a => a -> Set a -> Set a
Set.insert
([Text] -> Text
Text.unlines [ [Char] -> Text
pack ([Char]
"binary-fixup" [Char] -> [Char] -> [Char]
</> BinPkgName -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"::"
, Text
"\tinstall -Dp " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
src Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack ([Char]
"debian" [Char] -> [Char] -> [Char]
</> BinPkgName -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b [Char] -> [Char] -> [Char]
</> [Char] -> [Char] -> [Char]
makeRelative [Char]
"/" [Char]
dest) ])
doAtom Atom
_ = () -> StateT CabalInfo m ()
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
expandFile :: Monad m => CabalT m ()
expandFile :: forall (m :: * -> *). Monad m => CabalT m ()
expandFile =
Getting (Set Atom) CabalInfo (Set Atom)
-> StateT CabalInfo m (Set Atom)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Set Atom) DebInfo)
-> CabalInfo -> Const (Set Atom) CabalInfo)
-> ((Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo)
-> Getting (Set Atom) CabalInfo (Set Atom)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Const (Set Atom) (Set Atom))
-> DebInfo -> Const (Set Atom) DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) StateT CabalInfo m (Set Atom)
-> (Set Atom -> StateT CabalInfo m ()) -> StateT CabalInfo m ()
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Atom -> StateT CabalInfo m ()) -> [Atom] -> StateT CabalInfo m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ Atom -> StateT CabalInfo m ()
forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom ([Atom] -> StateT CabalInfo m ())
-> (Set Atom -> [Atom]) -> Set Atom -> StateT CabalInfo m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set Atom -> [Atom]
forall a. Set a -> [a]
Set.toList
where
doAtom :: Monad m => D.Atom -> CabalT m ()
doAtom :: forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom (D.File BinPkgName
b [Char]
path Text
text) =
do let ([Char]
destDir', [Char]
destName') = [Char] -> ([Char], [Char])
splitFileName [Char]
path
tmpDir :: [Char]
tmpDir = [Char]
"debian/cabalInstall" [Char] -> [Char] -> [Char]
</> MD5Digest -> [Char]
forall a. Show a => a -> [Char]
show (ByteString -> MD5Digest
md5 ([Char] -> ByteString
fromString (Text -> [Char]
unpack Text
text)))
tmpPath :: [Char]
tmpPath = [Char]
tmpDir [Char] -> [Char] -> [Char]
</> [Char]
destName'
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set ([Char], Text) -> Identity (Set ([Char], Text)))
-> DebInfo -> Identity DebInfo)
-> (Set ([Char], Text) -> Identity (Set ([Char], Text)))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set ([Char], Text) -> Identity (Set ([Char], Text)))
-> DebInfo -> Identity DebInfo
Lens' DebInfo (Set ([Char], Text))
D.intermediateFiles) ((Set ([Char], Text) -> Identity (Set ([Char], Text)))
-> CabalInfo -> Identity CabalInfo)
-> (Set ([Char], Text) -> Set ([Char], Text)) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char], Text) -> Set ([Char], Text) -> Set ([Char], Text)
forall a. Ord a => a -> Set a -> Set a
Set.insert ([Char]
tmpPath, Text
text)
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set Atom -> Identity (Set Atom))
-> DebInfo -> Identity DebInfo)
-> (Set Atom -> Identity (Set Atom))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Atom -> Identity (Set Atom)) -> DebInfo -> Identity DebInfo
Lens' DebInfo (Set Atom)
D.atomSet) ((Set Atom -> Identity (Set Atom))
-> CabalInfo -> Identity CabalInfo)
-> (Set Atom -> Set Atom) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Atom -> Set Atom -> Set Atom
forall a. Ord a => a -> Set a -> Set a
Set.insert (Atom -> Set Atom -> Set Atom) -> Atom -> Set Atom -> Set Atom
forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.Install BinPkgName
b [Char]
tmpPath [Char]
destDir')
doAtom Atom
_ = () -> CabalT m ()
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
expandExecutable :: Monad m => CabalT m ()
expandExecutable :: forall (m :: * -> *). Monad m => CabalT m ()
expandExecutable =
do Map BinPkgName InstallFile
mp <- StateT CabalInfo m CabalInfo
forall s (m :: * -> *). MonadState s m => m s
get StateT CabalInfo m CabalInfo
-> (CabalInfo -> StateT CabalInfo m (Map BinPkgName InstallFile))
-> StateT CabalInfo m (Map BinPkgName InstallFile)
forall a b.
StateT CabalInfo m a
-> (a -> StateT CabalInfo m b) -> StateT CabalInfo m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Map BinPkgName InstallFile
-> StateT CabalInfo m (Map BinPkgName InstallFile)
forall a. a -> StateT CabalInfo m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Map BinPkgName InstallFile
-> StateT CabalInfo m (Map BinPkgName InstallFile))
-> (CabalInfo -> Map BinPkgName InstallFile)
-> CabalInfo
-> StateT CabalInfo m (Map BinPkgName InstallFile)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting
(Map BinPkgName InstallFile) CabalInfo (Map BinPkgName InstallFile)
-> CabalInfo -> Map BinPkgName InstallFile
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view ((DebInfo -> Const (Map BinPkgName InstallFile) DebInfo)
-> CabalInfo -> Const (Map BinPkgName InstallFile) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Map BinPkgName InstallFile) DebInfo)
-> CabalInfo -> Const (Map BinPkgName InstallFile) CabalInfo)
-> ((Map BinPkgName InstallFile
-> Const (Map BinPkgName InstallFile) (Map BinPkgName InstallFile))
-> DebInfo -> Const (Map BinPkgName InstallFile) DebInfo)
-> Getting
(Map BinPkgName InstallFile) CabalInfo (Map BinPkgName InstallFile)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map BinPkgName InstallFile
-> Const (Map BinPkgName InstallFile) (Map BinPkgName InstallFile))
-> DebInfo -> Const (Map BinPkgName InstallFile) DebInfo
Lens' DebInfo (Map BinPkgName InstallFile)
D.executable)
((BinPkgName, InstallFile) -> CabalT m ())
-> [(BinPkgName, InstallFile)] -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ (\ (BinPkgName
b, InstallFile
f) -> (CabalInfo -> CabalInfo) -> CabalT m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (BinPkgName -> InstallFile -> CabalInfo -> CabalInfo
execAtoms BinPkgName
b InstallFile
f)) (Map BinPkgName InstallFile -> [(BinPkgName, InstallFile)]
forall k a. Map k a -> [(k, a)]
Map.toList Map BinPkgName InstallFile
mp)
finalizeRules :: (MonadIO m) => CabalT m ()
finalizeRules :: forall (m :: * -> *). MonadIO m => CabalT m ()
finalizeRules =
do DebBase [Char]
b <- CabalT m DebBase
forall (m :: * -> *). Monad m => CabalT m DebBase
debianNameBase
CompilerFlavor
hc <- Getting CompilerFlavor CabalInfo CompilerFlavor
-> StateT CabalInfo m CompilerFlavor
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const CompilerFlavor DebInfo)
-> CabalInfo -> Const CompilerFlavor CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const CompilerFlavor DebInfo)
-> CabalInfo -> Const CompilerFlavor CabalInfo)
-> ((CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> DebInfo -> Const CompilerFlavor DebInfo)
-> Getting CompilerFlavor CabalInfo CompilerFlavor
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Flags -> Const CompilerFlavor Flags)
-> DebInfo -> Const CompilerFlavor DebInfo
Lens' DebInfo Flags
D.flags ((Flags -> Const CompilerFlavor Flags)
-> DebInfo -> Const CompilerFlavor DebInfo)
-> ((CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> Flags -> Const CompilerFlavor Flags)
-> (CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> DebInfo
-> Const CompilerFlavor DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CompilerFlavor -> Const CompilerFlavor CompilerFlavor)
-> Flags -> Const CompilerFlavor Flags
Lens' Flags CompilerFlavor
compilerFlavor)
Maybe BinPkgName
cpn <- IO (Maybe BinPkgName) -> StateT CabalInfo m (Maybe BinPkgName)
forall a. IO a -> StateT CabalInfo m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BinPkgName) -> StateT CabalInfo m (Maybe BinPkgName))
-> IO (Maybe BinPkgName) -> StateT CabalInfo m (Maybe BinPkgName)
forall a b. (a -> b) -> a -> b
$ CompilerFlavor -> PackageType -> IO (Maybe BinPkgName)
compilerPackageName CompilerFlavor
hc PackageType
B.Development
let BinPkgName [Char]
hcdeb = BinPkgName -> Maybe BinPkgName -> BinPkgName
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> BinPkgName
forall a. HasCallStack => [Char] -> a
error [Char]
"No compiler package") Maybe BinPkgName
cpn
((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> f DebInfo) -> CabalInfo -> f CabalInfo)
-> ((Maybe Text -> f (Maybe Text)) -> DebInfo -> f DebInfo)
-> (Maybe Text -> f (Maybe Text))
-> CabalInfo
-> f CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe Text -> f (Maybe Text)) -> DebInfo -> f DebInfo
Lens' DebInfo (Maybe Text)
D.rulesHead) (forall {f :: * -> *}.
Functor f =>
(Maybe Text -> f (Maybe Text)) -> CabalInfo -> f CabalInfo)
-> Maybe Text -> CabalT m ()
forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"#!/usr/bin/make -f"
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> (([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo)
-> ([Text] -> Identity [Text])
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo
Lens' DebInfo [Text]
D.rulesSettings) (([Text] -> Identity [Text]) -> CabalInfo -> Identity CabalInfo)
-> ([Text] -> [Text]) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text
"DEB_CABAL_PACKAGE = " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
b])
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> (([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo)
-> ([Text] -> Identity [Text])
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo
Lens' DebInfo [Text]
D.rulesSettings) (([Text] -> Identity [Text]) -> CabalInfo -> Identity CabalInfo)
-> ([Text] -> [Text]) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text
"DEB_DEFAULT_COMPILER = " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
hcdeb])
[Char]
flags <- [(FlagName, Bool)] -> [Char]
flagString ([(FlagName, Bool)] -> [Char])
-> (Set (FlagName, Bool) -> [(FlagName, Bool)])
-> Set (FlagName, Bool)
-> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set (FlagName, Bool) -> [(FlagName, Bool)]
forall a. Set a -> [a]
Set.toList (Set (FlagName, Bool) -> [Char])
-> StateT CabalInfo m (Set (FlagName, Bool))
-> StateT CabalInfo m [Char]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Getting (Set (FlagName, Bool)) CabalInfo (Set (FlagName, Bool))
-> StateT CabalInfo m (Set (FlagName, Bool))
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Set (FlagName, Bool)) DebInfo)
-> CabalInfo -> Const (Set (FlagName, Bool)) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Set (FlagName, Bool)) DebInfo)
-> CabalInfo -> Const (Set (FlagName, Bool)) CabalInfo)
-> ((Set (FlagName, Bool)
-> Const (Set (FlagName, Bool)) (Set (FlagName, Bool)))
-> DebInfo -> Const (Set (FlagName, Bool)) DebInfo)
-> Getting (Set (FlagName, Bool)) CabalInfo (Set (FlagName, Bool))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Flags -> Const (Set (FlagName, Bool)) Flags)
-> DebInfo -> Const (Set (FlagName, Bool)) DebInfo
Lens' DebInfo Flags
D.flags ((Flags -> Const (Set (FlagName, Bool)) Flags)
-> DebInfo -> Const (Set (FlagName, Bool)) DebInfo)
-> ((Set (FlagName, Bool)
-> Const (Set (FlagName, Bool)) (Set (FlagName, Bool)))
-> Flags -> Const (Set (FlagName, Bool)) Flags)
-> (Set (FlagName, Bool)
-> Const (Set (FlagName, Bool)) (Set (FlagName, Bool)))
-> DebInfo
-> Const (Set (FlagName, Bool)) DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set (FlagName, Bool)
-> Const (Set (FlagName, Bool)) (Set (FlagName, Bool)))
-> Flags -> Const (Set (FlagName, Bool)) Flags
Lens' Flags (Set (FlagName, Bool))
cabalFlagAssignments)
Bool -> CabalT m () -> CabalT m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null [Char]
flags) (((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> (([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo)
-> ([Text] -> Identity [Text])
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo
Lens' DebInfo [Text]
D.rulesSettings) (([Text] -> Identity [Text]) -> CabalInfo -> Identity CabalInfo)
-> ([Text] -> [Text]) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text
"DEB_SETUP_GHC_CONFIGURE_ARGS = " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
flags]))
((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> (([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo)
-> ([Text] -> Identity [Text])
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Identity [Text]) -> DebInfo -> Identity DebInfo
Lens' DebInfo [Text]
D.rulesIncludes) (([Text] -> Identity [Text]) -> CabalInfo -> Identity CabalInfo)
-> ([Text] -> [Text]) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text
"include /usr/share/cdbs/1/rules/debhelper.mk",
Text
"include /usr/share/cdbs/1/class/hlibrary.mk"])
data Dependency_
= BuildDepends Dependency
| BuildTools Dependency
| PkgConfigDepends Dependency
| Relations
deriving (Dependency_ -> Dependency_ -> Bool
(Dependency_ -> Dependency_ -> Bool)
-> (Dependency_ -> Dependency_ -> Bool) -> Eq Dependency_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Dependency_ -> Dependency_ -> Bool
== :: Dependency_ -> Dependency_ -> Bool
$c/= :: Dependency_ -> Dependency_ -> Bool
/= :: Dependency_ -> Dependency_ -> Bool
Eq, Int -> Dependency_ -> [Char] -> [Char]
[Dependency_] -> [Char] -> [Char]
Dependency_ -> [Char]
(Int -> Dependency_ -> [Char] -> [Char])
-> (Dependency_ -> [Char])
-> ([Dependency_] -> [Char] -> [Char])
-> Show Dependency_
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
$cshowsPrec :: Int -> Dependency_ -> [Char] -> [Char]
showsPrec :: Int -> Dependency_ -> [Char] -> [Char]
$cshow :: Dependency_ -> [Char]
show :: Dependency_ -> [Char]
$cshowList :: [Dependency_] -> [Char] -> [Char]
showList :: [Dependency_] -> [Char] -> [Char]
Show)
anyrel :: String -> [D.Relation]
anyrel :: [Char] -> [Relation]
anyrel [Char]
x = BinPkgName -> [Relation]
anyrel' ([Char] -> BinPkgName
D.BinPkgName [Char]
x)
anyrel' :: D.BinPkgName -> [D.Relation]
anyrel' :: BinPkgName -> [Relation]
anyrel' BinPkgName
x = [BinPkgName -> Maybe VersionReq -> Maybe ArchitectureReq -> Relation
D.Rel BinPkgName
x Maybe VersionReq
forall a. Maybe a
Nothing Maybe ArchitectureReq
forall a. Maybe a
Nothing]
flagList :: String -> [(FlagName, Bool)]
flagList :: [Char] -> [(FlagName, Bool)]
flagList = ([Char] -> (FlagName, Bool)) -> [[Char]] -> [(FlagName, Bool)]
forall a b. (a -> b) -> [a] -> [b]
List.map [Char] -> (FlagName, Bool)
tagWithValue ([[Char]] -> [(FlagName, Bool)])
-> ([Char] -> [[Char]]) -> [Char] -> [(FlagName, Bool)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
words
where tagWithValue :: [Char] -> (FlagName, Bool)
tagWithValue (Char
'-':[Char]
name) = ([Char] -> FlagName
mkFlagName ((Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> Char
toLower [Char]
name), Bool
False)
tagWithValue [Char]
name = ([Char] -> FlagName
mkFlagName ((Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> Char
toLower [Char]
name), Bool
True)
flagString :: [(FlagName, Bool)] -> String
flagString :: [(FlagName, Bool)] -> [Char]
flagString = [[Char]] -> [Char]
unwords ([[Char]] -> [Char])
-> ([(FlagName, Bool)] -> [[Char]]) -> [(FlagName, Bool)] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((FlagName, Bool) -> [Char]) -> [(FlagName, Bool)] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
List.map (\ (FlagName
s, Bool
sense) -> [Char]
"-f" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (if Bool
sense then [Char]
"" else [Char]
"-") [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ FlagName -> [Char]
unFlagName FlagName
s)