-- | Compute the debianization of a cabal package.
{-# LANGUAGE CPP, FlexibleContexts, FlexibleInstances, OverloadedStrings, ScopedTypeVariables, TemplateHaskell #-}
module Debian.Debianize.Finalize
    ( debianize
    , debianizeWith
    , debianizeWebsite
    -- , finalizeDebianization -- external use deprecated - used in test script
    , 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, {-description,-} 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 customize@ initializes the CabalT state from the
-- environment and the cabal package description in (and possibly the
-- debian/changelog file) from the current directory, then runs
-- @customize@ and finalizes the debianization so it is ready to be
-- output.
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)

-- | Pass a function with some additional work to do.  I don't know
-- if this could be done by just summing it with customize - probably.
-- But I don't want to untangle this right now.
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

-- | Do some light IO and call finalizeDebianization.
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)

-- | Now that we know the build and data directories, we can expand
-- some atoms into sets of simpler atoms which can eventually be
-- turned into the files of the debianization.  The original atoms are
-- not removed from the list because they may contribute to the
-- debianization in other ways, so be careful not to do this twice,
-- this function is not idempotent.  (Exported for use in unit tests.)
-- FIXME: we should be able to run this without a PackageDescription, change
--        paramter type to Maybe PackageDescription and propagate down thru code
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 -- In reality, hcs must be a singleton or many things won't work.  But some day...
       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
       -- T.license .?= Just (Cabal.license pkgDesc)
       CabalT m () -> CabalT m ()
forall (m :: * -> *). Monad m => CabalT m () -> CabalT m ()
expandAtoms CabalT m ()
goodies
       -- Create the binary packages for the web sites, servers, backup packges, and other executables
       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
       -- Make sure all the control file sections exist before doing the build dependencies,
       -- because we need to filter out self dependencies.
       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
       -- Sketchy - I think more things that need expanded could be generated by the code
       -- executed since the last expandAtoms.  Anyway, should be idempotent.
       CabalT m () -> CabalT m ()
forall (m :: * -> *). Monad m => CabalT m () -> CabalT m ()
expandAtoms CabalT m ()
goodies
       -- Turn atoms related to priority, section, and description into debianization elements
       -- finalizeDescriptions

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"

-- | Compute the final values of the BinaryDebDescription record
-- description fields from the cabal descriptions and the values that
-- have already been set.
{-
finalizeDescriptions :: (Monad m, Functor m) => CabalT m ()
finalizeDescriptions = use T.binaryPackages >>= List.mapM_ finalizeDescription

finalizeDescription :: (Monad m, Functor m) => B.BinaryDebDescription -> CabalT m ()
finalizeDescription bdd =
    do let b = view B.package bdd
       cabDesc <- describe
       T.debianDescription .?= Just cabDesc
-}

-- | Construct the final Debian version number.
--  Inputs:
--
--    1. --deb-version argument
--    2. --revision argument
--    3. cabal version number
--    4. latest version in debian/changelog
--
-- The --deb-version argument overrides everything.
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) -- from the --revision option
              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) -- from the --deb-version option
       (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

-- | Return the Debian epoch number assigned to the given cabal
-- package - the 1 in version numbers like 1:3.5-2.
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

-- | Compute and return the debian source package name, based on the
-- sourcePackageName if it was specified, and constructed from the
-- cabal name otherwise.
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
                              -- Haskell source deb names conventionally have the prefix
                              -- "haskell-" added.  Here we add prefix "ghcjs-" to
                              -- haskell packages build with the ghcjs compiler.
                              (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))

-- | Try to compute a string for the the debian "Maintainer:" and
-- "Uploaders:" fields using, in this order
--    1. the Debian Haskell Group, @pkg-haskell-maintainers\@lists.alioth.debian.org@,
--       if --official is set
--    2. the maintainer explicitly specified using "Debian.Debianize.Monad.maintainer"
--    3. the maintainer field of the cabal package, but only if --official is not set,
--    4. the value returned by getDebianMaintainer, which looks in several environment variables,
--    5. the signature from the latest entry in debian/changelog,
--    6. the Debian Haskell Group, @pkg-haskell-maintainers\@lists.alioth.debian.org@
-- <http://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Maintainer>
-- <http://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Uploaders>
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 -- Just $ NameAddr (Just "Invalid signature in changelog") (show e)
                 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
      -- Sometimes the maintainer is just an email, if it matches the author's email we can use it
      ((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
      -- Sometimes the maintainer is just an email, try combining it with the author's name
      ((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

-- | If l is the empty list return d, otherwise return l.
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'
       -- control %= (\ y -> y { D.source = Just src, D.maintainer = Just maint })

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 {- <> "\n" <>
          case typ of
            Just B.Profiling ->
                Text.intercalate "\n"
                        [" .",
                         " This package provides a library for the Haskell programming language, compiled",
                         " for profiling.  See http:///www.haskell.org/ for more information on Haskell."]
            Just B.Development ->
                Text.intercalate "\n"
                        [" .",
                         " This package provides a library for the Haskell programming language.",
                         " See http:///www.haskell.org/ for more information on Haskell."]
            Just B.Documentation ->
                Text.intercalate "\n"
                        [" .",
                         " This package provides the documentation for a library for the Haskell",
                         " programming language.",
                         " See http:///www.haskell.org/ for more information on Haskell." ]
            Just B.Exec ->
                Text.intercalate "\n"
                        [" .",
                         " An executable built from the " <> pack (display (pkgName (Cabal.package p))) <> " package."]
      {-    ServerPackage ->
                Text.intercalate "\n"
                        [" .",
                         " A server built from the " <> pack (display (pkgName pkgId)) <> " package."] -}
            _ {-Utilities-} ->
                Text.intercalate "\n"
                        [" .",
                         " Files associated with the " <> pack (display (pkgName (Cabal.package p))) <> " package."]
            -- x -> error $ "Unexpected library package name suffix: " ++ show x
-}

-- | The Cabal package has one synopsis and one description field
-- for the entire package, while in a Debian package there is a
-- description field (of which the first line is synopsis) in
-- each binary package.  So the cabal description forms the base
-- of the debian description, each of which is amended.
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
      -- If we have a one line description and no synopsis, use
      -- the description as the synopsis.
      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
      -- I don't know why (unwords . words) was applied here.  Maybe I'll find out when
      -- this version goes into production.  :-/  Ok, now I know, because sometimes the
      -- short cabal description has more than one line.
      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

-- | Make sure there is a changelog entry with the version number and
-- source package name implied by the debianization.  This means
-- either adding an entry or modifying the latest entry (if its
-- version number is the exact one in our debianization.)
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
       -- pkgDesc <- use T.packageDescription >>= return . maybe Nothing (either Nothing Just . parseMaintainer . Cabal.maintainer)
       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
      -- Ensure that the package name is correct in the first log entry.
      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))
      -- The newest log entry isn't exactly ver, build a new entry.
      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
          -- Creating new log entry for version
          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))

-- | Convert the extraLibs field of the cabal build info into debian
-- binary package names and make them dependendencies of the debian
-- devel package (if there is one.)
addExtraLibDependencies :: (Monad m) => CompilerFlavor -> CabalT m ()
addExtraLibDependencies :: forall (m :: * -> *). Monad m => CompilerFlavor -> CabalT m ()
addExtraLibDependencies 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)

-- | Applies a few settings to official packages (unless already set)
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

-- | Filter out any relations that mention any of the bad package names.
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 -- yeah, this same line is all over the place.
       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]
:)

-- | Add the library paragraphs for a particular compiler flavor.
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

-- | This is the standard value for the Description field of a binary
-- package control file stanza.
desc :: Text
desc :: Text
desc = Text -> [Text] -> Text
Text.intercalate Text
"\n "
         [Text
"${haskell:ShortDescription}${haskell:ShortBlurb}",
          Text
"${haskell:LongDescription}",
          Text
".",
          Text
"${haskell:Blurb}"]

-- | Make sure all data and executable files are assigned to at least
-- one binary package and make sure all binary packages are in the
-- package list in the source deb description.  If there are left over
-- files, assign them to the packages returned by the
-- utilsPackageNames lens, and make sure those packages are in the
-- source deb description.
makeUtilsPackage :: forall m. (Monad m) => PackageDescription -> CompilerFlavor -> CabalT m ()
makeUtilsPackage :: forall (m :: * -> *).
Monad m =>
PackageDescription -> CompilerFlavor -> CabalT m ()
makeUtilsPackage PackageDescription
pkgDesc CompilerFlavor
hc =
    do -- Files the cabal package expects to be installed
       -- Files that are already assigned to any binary deb
       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))

       -- The names of cabal executables that go into eponymous debs
       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

       -- Files that are installed into packages other than the utils packages
       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

       -- Files that will be in utils packages
       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
       -- Files that still need to be assigned to the utils packages
       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
       -- If any files belong in the utils packages, make sure they exist
       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
         -- This is really for all binary debs except the libraries - I'm not sure why
         ((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
       -- Add the unassigned files to the utils packages
       (([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)

      -- Turn A.InstallCabalExec into A.Install
      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)
            -- A GHCJS executable is a directory with files, copy them
            -- all into place.
            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 ()

      -- Turn A.InstallCabalExecTo into a make rule
      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 ()

      -- Turn A.InstallData into either an Install or an InstallTo
      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 ()

      -- Turn A.InstallTo into a make rule
      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 ()

      -- Turn A.File into an intermediateFile and an A.Install
      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)

-- | Add the normal default values to the rules files.
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
  | ExtraLibs 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]

-- Lifted from Distribution.Simple.Setup, since it's not exported.
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)