-- | 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 :: 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 (m :: * -> *) a. Monad m => a -> m a
return ())

debianizeWebsite :: (MonadIO m, MonadFail m) => CabalT m () -> CabalT m ()
debianizeWebsite :: 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 (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 (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 :: 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 :: CabalT m () -> CabalT m ()
finalizeDebianization CabalT m ()
goodies =
    do String
date <- IO String -> StateT CabalInfo m String
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO String
getCurrentLocalRFC822Time
       Maybe NameAddr
currentUser <- IO (Maybe NameAddr) -> StateT CabalInfo m (Maybe NameAddr)
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 (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
<$> (String -> StateT CabalInfo m Bool)
-> [String] -> StateT CabalInfo m [Bool]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (IO Bool -> StateT CabalInfo m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> StateT CabalInfo m Bool)
-> (String -> IO Bool) -> String -> StateT CabalInfo m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO Bool
doesFileExist) [String
"Setup.hs", String
"Setup.lhs"]
       CabalT m ()
-> String -> Maybe NameAddr -> Maybe Int -> Bool -> CabalT m ()
forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m ()
-> String -> Maybe NameAddr -> Maybe Int -> Bool -> CabalT m ()
finalizeDebianization' CabalT m ()
goodies String
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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ CabalInfo
x -> IO () -> CabalT m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (String -> IO ()
putStrLn (String
"\nFinalized Cabal Info: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ CabalInfo -> String
forall a. Show a => a -> String
show CabalInfo
x String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\n")))
       (String -> CabalT m ())
-> (NameAddr -> CabalT m ())
-> Either String NameAddr
-> CabalT m ()
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\String
e -> IO () -> CabalT m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> CabalT m ()) -> IO () -> CabalT m ()
forall a b. (a -> b) -> a -> b
$ Handle -> String -> IO ()
hPutStrLn Handle
stderr (String
"WARNING: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
e)) (\NameAddr
_ -> () -> CabalT m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()) (Either String NameAddr -> CabalT m ())
-> StateT CabalInfo m (Either String NameAddr) -> CabalT m ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Getting (Either String NameAddr) CabalInfo (Either String NameAddr)
-> StateT CabalInfo m (Either String NameAddr)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Either String NameAddr) DebInfo)
-> CabalInfo -> Const (Either String NameAddr) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Either String NameAddr) DebInfo)
 -> CabalInfo -> Const (Either String NameAddr) CabalInfo)
-> ((Either String NameAddr
     -> Const (Either String NameAddr) (Either String NameAddr))
    -> DebInfo -> Const (Either String NameAddr) DebInfo)
-> Getting
     (Either String NameAddr) CabalInfo (Either String NameAddr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription
 -> Const (Either String NameAddr) SourceDebDescription)
-> DebInfo -> Const (Either String NameAddr) DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription
  -> Const (Either String NameAddr) SourceDebDescription)
 -> DebInfo -> Const (Either String NameAddr) DebInfo)
-> ((Either String NameAddr
     -> Const (Either String NameAddr) (Either String NameAddr))
    -> SourceDebDescription
    -> Const (Either String NameAddr) SourceDebDescription)
-> (Either String NameAddr
    -> Const (Either String NameAddr) (Either String NameAddr))
-> DebInfo
-> Const (Either String NameAddr) DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either String NameAddr
 -> Const (Either String NameAddr) (Either String NameAddr))
-> SourceDebDescription
-> Const (Either String NameAddr) SourceDebDescription
Lens' SourceDebDescription (Either String 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' :: CabalT m ()
-> String -> Maybe NameAddr -> Maybe Int -> Bool -> CabalT m ()
finalizeDebianization' CabalT m ()
goodies String
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 (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 (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 (String -> Section
MainSection String
"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
       String -> Maybe NameAddr -> CabalT m ()
forall (m :: * -> *).
Monad m =>
String -> Maybe NameAddr -> CabalT m ()
finalizeChangelog String
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 (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 String) CabalInfo (Map BinPkgName String)
-> StateT CabalInfo m (Map BinPkgName String)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Map BinPkgName String) DebInfo)
-> CabalInfo -> Const (Map BinPkgName String) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Map BinPkgName String) DebInfo)
 -> CabalInfo -> Const (Map BinPkgName String) CabalInfo)
-> ((Map BinPkgName String
     -> Const (Map BinPkgName String) (Map BinPkgName String))
    -> DebInfo -> Const (Map BinPkgName String) DebInfo)
-> Getting
     (Map BinPkgName String) CabalInfo (Map BinPkgName String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map BinPkgName String
 -> Const (Map BinPkgName String) (Map BinPkgName String))
-> DebInfo -> Const (Map BinPkgName String) DebInfo
Lens' DebInfo (Map BinPkgName String)
D.backups) StateT CabalInfo m (Map BinPkgName String)
-> (Map BinPkgName String -> CabalT m ()) -> CabalT m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ((BinPkgName, String) -> CabalT m ())
-> [(BinPkgName, String)] -> 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, String) -> BinPkgName)
-> (BinPkgName, String)
-> CabalT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (BinPkgName, String) -> BinPkgName
forall a b. (a, b) -> a
fst) ([(BinPkgName, String)] -> CabalT m ())
-> (Map BinPkgName String -> [(BinPkgName, String)])
-> Map BinPkgName String
-> CabalT m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map BinPkgName String -> [(BinPkgName, String)]
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 (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 (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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [BinPkgName] -> StateT CabalInfo m [BinPkgName]
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 =
    String -> Text
pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ String
"version=3\nhttps://hackage.haskell.org/package/" String -> String -> String
forall a. [a] -> [a] -> [a]
++ PackageName -> String
unPackageName PackageName
pkgname String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"/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 :: 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) <- (String -> DebianVersion
forall string. ParseDebianVersion string => string -> DebianVersion
V.parseDebianVersion' (String -> DebianVersion)
-> (PackageDescription -> String)
-> PackageDescription
-> DebianVersion
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Version -> String
forall a. Pretty (PP a) => a -> String
ppShow (Version -> String)
-> (PackageDescription -> Version) -> PackageDescription -> String
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 String
cabalRevision <-
           do Maybe String
x <- Getting (Maybe String) CabalInfo (Maybe String)
-> StateT CabalInfo m (Maybe String)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe String) DebInfo)
-> CabalInfo -> Const (Maybe String) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe String) DebInfo)
 -> CabalInfo -> Const (Maybe String) CabalInfo)
-> ((Maybe String -> Const (Maybe String) (Maybe String))
    -> DebInfo -> Const (Maybe String) DebInfo)
-> Getting (Maybe String) CabalInfo (Maybe String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe String -> Const (Maybe String) (Maybe String))
-> DebInfo -> Const (Maybe String) DebInfo
Lens' DebInfo (Maybe String)
D.revision) -- from the --revision option
              let y :: Maybe String
y = case Maybe String
x of
                        Maybe String
Nothing -> Maybe String
forall a. Maybe a
Nothing
                        Just String
"" -> Maybe String
forall a. Maybe a
Nothing
                        Just String
"-" -> Maybe String
forall a. Maybe a
Nothing
                        Just (Char
'-':String
r) -> String -> Maybe String
forall a. a -> Maybe a
Just String
r
                        Just String
_ -> String -> Maybe String
forall a. HasCallStack => String -> a
error String
"The --revision argument must start with a dash"
              Maybe String -> StateT CabalInfo m (Maybe String)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe String -> StateT CabalInfo m (Maybe String))
-> Maybe String -> StateT CabalInfo m (Maybe String)
forall a b. (a -> b) -> a -> b
$ case SourceFormat
fmt of
                         SourceFormat
Native3 -> Maybe String
y
                         SourceFormat
_ -> Maybe String
-> (String -> Maybe String) -> Maybe String -> Maybe String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Maybe String
forall a. a -> Maybe a
Just String
"1") (String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String)
-> (String -> String) -> String -> Maybe String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String -> String
forall a. Ord a => a -> a -> a
max String
"1") Maybe String
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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Maybe DebianVersion -> StateT CabalInfo m (Maybe DebianVersion)
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 -> String -> Maybe String -> DebianVersion
V.buildDebianVersion Maybe Int
cabalEpoch (DebianVersion -> String
forall a. Pretty (PP a) => a -> String
ppShow DebianVersion
cabalVersion) Maybe String
forall a. Maybe a
Nothing) Maybe DebianVersion
versionArg ->
               String -> CabalT m DebianVersion
forall a. HasCallStack => String -> a
error (String
"Version from --deb-version (" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Maybe DebianVersion -> String
forall a. Pretty (PP a) => a -> String
ppShow Maybe DebianVersion
versionArg String -> String -> String
forall a. [a] -> [a] -> [a]
++
                      String
") is older than cabal version (" String -> String -> String
forall a. [a] -> [a] -> [a]
++ DebianVersion -> String
forall a. Pretty (PP a) => a -> String
ppShow DebianVersion
cabalVersion String -> String -> String
forall a. [a] -> [a] -> [a]
++
                      String
"), maybe you need to unpin this package?")
         ()
_ | Maybe DebianVersion -> Bool
forall a. Maybe a -> Bool
isJust Maybe DebianVersion
versionArg -> DebianVersion -> CabalT m DebianVersion
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),
                     String -> DebianVersion
forall string. ParseDebianVersion string => string -> DebianVersion
V.parseDebianVersion' (DebianVersion -> String
V.version (Maybe DebianVersion -> DebianVersion
forall a. HasCallStack => Maybe a -> a
fromJust Maybe DebianVersion
debVersion)),
                     DebianVersion -> Maybe String
V.revision (Maybe DebianVersion -> DebianVersion
forall a. HasCallStack => Maybe a -> a
fromJust Maybe DebianVersion
debVersion)) of
                 (Maybe Int
debEpoch, DebianVersion
debianVersion', (Maybe String
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 String
finalRevision :: Maybe String) = (Maybe String -> Maybe String -> Ordering)
-> [Maybe String] -> Maybe String
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 String -> Maybe DebianVersion)
-> Maybe String
-> Maybe String
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` (String -> DebianVersion) -> Maybe String -> Maybe DebianVersion
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> DebianVersion
forall string. ParseDebianVersion string => string -> DebianVersion
V.parseDebianVersion') [Maybe String
debianRevision, Maybe String
cabalRevision] in
                     DebianVersion -> CabalT m DebianVersion
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 -> String -> Maybe String -> DebianVersion
V.buildDebianVersion Maybe Int
finalEpoch (DebianVersion -> String
forall a. Pretty (PP a) => a -> String
ppShow DebianVersion
finalVersion) Maybe String
finalRevision
         ()
_ -> DebianVersion -> CabalT m DebianVersion
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 -> String -> Maybe String -> DebianVersion
V.buildDebianVersion Maybe Int
cabalEpoch (DebianVersion -> String
forall a. Pretty (PP a) => a -> String
ppShow DebianVersion
cabalVersion) Maybe String
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 :: 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 -> CabalT m (Maybe Int)) -> CabalT m (Maybe Int)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Maybe Int -> CabalT m (Maybe Int)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Int -> CabalT m (Maybe Int))
-> (CabalInfo -> Maybe Int) -> CabalInfo -> CabalT 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 :: PackageType -> CabalT m ()
finalizeSourceName PackageType
typ =
    do DebBase String
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 (String -> 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) -> String
"haskell-" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
debName
                              (CompilerFlavor
GHCJS, PackageType
B.HaskellSource) -> String
"ghcjs-" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
debName
                              (CompilerFlavor
_, PackageType
B.Source) -> String
debName
                              (CompilerFlavor, PackageType)
_ -> String -> String
forall a. HasCallStack => String -> a
error (String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$ String
"finalizeSourceName: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ PackageType -> String
forall a. Show a => a -> String
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 :: 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 -> String
toString = ShortText -> String
ST.fromShortText
#else
  let toString = id
#endif
      cabalAuthorString :: String
cabalAuthorString = (Char -> Bool) -> String -> String
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 -> String
toString (PackageDescription -> ShortText
Cabal.author PackageDescription
pkgDesc))
      cabalMaintainerString :: String
cabalMaintainerString = (Char -> Bool) -> String -> String
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 -> String
toString (PackageDescription -> ShortText
Cabal.maintainer PackageDescription
pkgDesc))
      cabalMaintainerString' :: String
cabalMaintainerString' = String
cabalAuthorString String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
" <" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
cabalMaintainerString String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
">"
      cabalMaintainerString'' :: String
cabalMaintainerString'' = String
cabalAuthorString String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
" " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
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 (String -> Either String NameAddr
parseMaintainer (ChangeLogEntry -> String
logWho ChangeLogEntry
entry)) of
                 Left String
_e -> Maybe NameAddr -> StateT CabalInfo m (Maybe NameAddr)
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 (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 (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 String NameAddr -> Identity (Either String NameAddr))
    -> DebInfo -> Identity DebInfo)
-> (Either String NameAddr -> Identity (Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> SourceDebDescription -> Identity SourceDebDescription)
-> (Either String NameAddr -> Identity (Either String NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either String NameAddr -> Identity (Either String NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either String NameAddr)
S.maintainer) ((Either String NameAddr -> Identity (Either String NameAddr))
 -> CabalInfo -> Identity CabalInfo)
-> Either String NameAddr -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= NameAddr -> Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> DebInfo -> Identity DebInfo)
-> (Either String NameAddr -> Identity (Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> SourceDebDescription -> Identity SourceDebDescription)
-> (Either String NameAddr -> Identity (Either String NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either String NameAddr -> Identity (Either String NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either String NameAddr)
S.maintainer) ((Either String NameAddr -> Identity (Either String NameAddr))
 -> CabalInfo -> Identity CabalInfo)
-> (Either String NameAddr -> Either String NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (String -> Either String NameAddr)
-> (NameAddr -> Either String NameAddr)
-> Either String NameAddr
-> Either String NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\String
x -> Either String NameAddr
-> (NameAddr -> Either String NameAddr)
-> Maybe NameAddr
-> Either String NameAddr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Either String NameAddr
forall a b. a -> Either a b
Left String
x) NameAddr -> Either String NameAddr
forall a b. b -> Either a b
Right Maybe NameAddr
maintainerOption) NameAddr -> Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> DebInfo -> Identity DebInfo)
-> (Either String NameAddr -> Identity (Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> SourceDebDescription -> Identity SourceDebDescription)
-> (Either String NameAddr -> Identity (Either String NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either String NameAddr -> Identity (Either String NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either String NameAddr)
S.maintainer) ((Either String NameAddr -> Identity (Either String NameAddr))
 -> CabalInfo -> Identity CabalInfo)
-> (Either String NameAddr -> Either String NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (String -> Either String NameAddr)
-> (NameAddr -> Either String NameAddr)
-> Either String NameAddr
-> Either String NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\String
_ -> String -> Either String NameAddr
parseMaintainer String
cabalMaintainerString) NameAddr -> Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> DebInfo -> Identity DebInfo)
-> (Either String NameAddr -> Identity (Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> SourceDebDescription -> Identity SourceDebDescription)
-> (Either String NameAddr -> Identity (Either String NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either String NameAddr -> Identity (Either String NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either String NameAddr)
S.maintainer) ((Either String NameAddr -> Identity (Either String NameAddr))
 -> CabalInfo -> Identity CabalInfo)
-> (Either String NameAddr -> Either String NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (String -> Either String NameAddr)
-> (NameAddr -> Either String NameAddr)
-> Either String NameAddr
-> Either String NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\String
_ -> String -> Either String NameAddr
parseMaintainer String
cabalMaintainerString') NameAddr -> Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> DebInfo -> Identity DebInfo)
-> (Either String NameAddr -> Identity (Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> SourceDebDescription -> Identity SourceDebDescription)
-> (Either String NameAddr -> Identity (Either String NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either String NameAddr -> Identity (Either String NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either String NameAddr)
S.maintainer) ((Either String NameAddr -> Identity (Either String NameAddr))
 -> CabalInfo -> Identity CabalInfo)
-> (Either String NameAddr -> Either String NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (String -> Either String NameAddr)
-> (NameAddr -> Either String NameAddr)
-> Either String NameAddr
-> Either String NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\String
_ -> String -> Either String NameAddr
parseMaintainer String
cabalMaintainerString'') NameAddr -> Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> DebInfo -> Identity DebInfo)
-> (Either String NameAddr -> Identity (Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> SourceDebDescription -> Identity SourceDebDescription)
-> (Either String NameAddr -> Identity (Either String NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either String NameAddr -> Identity (Either String NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either String NameAddr)
S.maintainer) ((Either String NameAddr -> Identity (Either String NameAddr))
 -> CabalInfo -> Identity CabalInfo)
-> (Either String NameAddr -> Either String NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (String -> Either String NameAddr)
-> (NameAddr -> Either String NameAddr)
-> Either String NameAddr
-> Either String NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\String
e -> case String -> Either String NameAddr
parseMaintainer String
cabalAuthorString of
                                                                Right NameAddr
x | NameAddr -> String
nameAddr_addr NameAddr
x String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
cabalMaintainerString -> NameAddr -> Either String NameAddr
forall a b. b -> Either a b
Right NameAddr
x
                                                                Right NameAddr
_ -> String -> Either String NameAddr
forall a b. a -> Either a b
Left String
e
                                                                Left String
x -> String -> Either String NameAddr
forall a b. a -> Either a b
Left String
x) NameAddr -> Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> DebInfo -> Identity DebInfo)
-> (Either String NameAddr -> Identity (Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> SourceDebDescription -> Identity SourceDebDescription)
-> (Either String NameAddr -> Identity (Either String NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either String NameAddr -> Identity (Either String NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either String NameAddr)
S.maintainer) ((Either String NameAddr -> Identity (Either String NameAddr))
 -> CabalInfo -> Identity CabalInfo)
-> (Either String NameAddr -> Either String NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (String -> Either String NameAddr)
-> (NameAddr -> Either String NameAddr)
-> Either String NameAddr
-> Either String NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\String
e -> case String -> Either String NameAddr
parseMaintainer String
cabalAuthorString of
                                                                Right (NameAddr {nameAddr_name :: NameAddr -> Maybe String
nameAddr_name = Just String
name}) -> String -> Either String NameAddr
parseMaintainer (String
name String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" <" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
cabalMaintainerString String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
">")
                                                                Right NameAddr
_ -> String -> Either String NameAddr
forall a b. a -> Either a b
Left String
e
                                                                Left String
x -> String -> Either String NameAddr
forall a b. a -> Either a b
Left String
x) NameAddr -> Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> DebInfo -> Identity DebInfo)
-> (Either String NameAddr -> Identity (Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> SourceDebDescription -> Identity SourceDebDescription)
-> (Either String NameAddr -> Identity (Either String NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either String NameAddr -> Identity (Either String NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either String NameAddr)
S.maintainer) ((Either String NameAddr -> Identity (Either String NameAddr))
 -> CabalInfo -> Identity CabalInfo)
-> (Either String NameAddr -> Either String NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (String -> Either String NameAddr)
-> (NameAddr -> Either String NameAddr)
-> Either String NameAddr
-> Either String NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\String
e -> Either String NameAddr
-> (NameAddr -> Either String NameAddr)
-> Maybe NameAddr
-> Either String NameAddr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Either String NameAddr
forall a b. a -> Either a b
Left String
e) NameAddr -> Either String NameAddr
forall a b. b -> Either a b
Right Maybe NameAddr
currentUser) NameAddr -> Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> DebInfo -> Identity DebInfo)
-> (Either String NameAddr -> Identity (Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> SourceDebDescription -> Identity SourceDebDescription)
-> (Either String NameAddr -> Identity (Either String NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either String NameAddr -> Identity (Either String NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either String NameAddr)
S.maintainer) ((Either String NameAddr -> Identity (Either String NameAddr))
 -> CabalInfo -> Identity CabalInfo)
-> (Either String NameAddr -> Either String NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (String -> Either String NameAddr)
-> (NameAddr -> Either String NameAddr)
-> Either String NameAddr
-> Either String NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\String
e -> Either String NameAddr
-> (NameAddr -> Either String NameAddr)
-> Maybe NameAddr
-> Either String NameAddr
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Either String NameAddr
forall a b. a -> Either a b
Left String
e) NameAddr -> Either String NameAddr
forall a b. b -> Either a b
Right Maybe NameAddr
changelogSignature) NameAddr -> Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> DebInfo -> Identity DebInfo)
-> (Either String NameAddr -> Identity (Either String 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 String NameAddr -> Identity (Either String NameAddr))
    -> SourceDebDescription -> Identity SourceDebDescription)
-> (Either String NameAddr -> Identity (Either String NameAddr))
-> DebInfo
-> Identity DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either String NameAddr -> Identity (Either String NameAddr))
-> SourceDebDescription -> Identity SourceDebDescription
Lens' SourceDebDescription (Either String NameAddr)
S.maintainer) ((Either String NameAddr -> Identity (Either String NameAddr))
 -> CabalInfo -> Identity CabalInfo)
-> (Either String NameAddr -> Either String NameAddr)
-> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (String -> Either String NameAddr)
-> (NameAddr -> Either String NameAddr)
-> Either String NameAddr
-> Either String NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\String
_ -> String -> Either String NameAddr
forall a b. a -> Either a b
Left (String
"Unable to construct a debian maintainer, using default.  Cabal maintainer strings tried:\n " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                                                                    String -> String
forall a. Show a => a -> String
show String
cabalMaintainerString String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
", " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
cabalMaintainerString' String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
", " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
cabalMaintainerString'' String -> String -> String
forall a. [a] -> [a] -> [a]
++
                                                                    String
", currentUser: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Maybe NameAddr -> String
forall a. Show a => a -> String
show Maybe NameAddr
currentUser)) NameAddr -> Either String 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 :: [a] -> [a] -> [a]
whenEmpty [a]
d [] = [a]
d
whenEmpty [a]
_ [a]
l = [a]
l

finalizeControl :: (MonadFail m) => Maybe NameAddr -> CabalT m ()
finalizeControl :: 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 :: 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 (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 =
    String -> Text
pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
List.intercalate String
"\n " ([String] -> String) -> [String] -> String
forall a b. (a -> b) -> a -> b
$ (String
synop' String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String]
desc')
    where
      -- If we have a one line description and no synopsis, use
      -- the description as the synopsis.
      synop' :: String
synop' = if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null String
synop Bool -> Bool -> Bool
&& [String] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [String]
desc' Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
1
               then String
"WARNING: No synopsis available for package " String -> String -> String
forall a. [a] -> [a] -> [a]
++ PackageIdentifier -> String
forall a. Pretty (PP a) => a -> String
ppShow (PackageDescription -> PackageIdentifier
package PackageDescription
p)
               else String
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 :: String
synop = String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
List.intercalate String
" " ([String] -> String) -> [String] -> String
forall a b. (a -> b) -> a -> b
$ (String -> String) -> [String] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
dropWhileEnd Char -> Bool
isSpace) ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ String -> [String]
lines (String -> [String]) -> String -> [String]
forall a b. (a -> b) -> a -> b
$ ShortText -> String
toString (ShortText -> String) -> ShortText -> String
forall a b. (a -> b) -> a -> b
$ PackageDescription -> ShortText
synopsis PackageDescription
p
      desc' :: [String]
      desc' :: [String]
desc' = (String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
List.map String -> String
forall (t :: * -> *) a. (Foldable t, IsString (t a)) => t a -> t a
addDot ([String] -> [String])
-> ([String] -> [String]) -> [String] -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Bool) -> [String] -> [String]
forall a. (a -> Bool) -> [a] -> [a]
stripWith String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ (String -> String) -> [String] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
dropWhileEnd Char -> Bool
isSpace) ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ String -> [String]
lines (String -> [String]) -> String -> [String]
forall a b. (a -> b) -> a -> b
$ ShortText -> String
toString (ShortText -> String) -> ShortText -> String
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 (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 -> String
toString = ShortText -> String
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 :: String -> Maybe NameAddr -> CabalT m ()
finalizeChangelog String
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 String NameAddr
debianMaintainer <- Getting (Either String NameAddr) CabalInfo (Either String NameAddr)
-> StateT CabalInfo m (Either String NameAddr)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Either String NameAddr) DebInfo)
-> CabalInfo -> Const (Either String NameAddr) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Either String NameAddr) DebInfo)
 -> CabalInfo -> Const (Either String NameAddr) CabalInfo)
-> ((Either String NameAddr
     -> Const (Either String NameAddr) (Either String NameAddr))
    -> DebInfo -> Const (Either String NameAddr) DebInfo)
-> Getting
     (Either String NameAddr) CabalInfo (Either String NameAddr)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceDebDescription
 -> Const (Either String NameAddr) SourceDebDescription)
-> DebInfo -> Const (Either String NameAddr) DebInfo
Lens' DebInfo SourceDebDescription
D.control ((SourceDebDescription
  -> Const (Either String NameAddr) SourceDebDescription)
 -> DebInfo -> Const (Either String NameAddr) DebInfo)
-> ((Either String NameAddr
     -> Const (Either String NameAddr) (Either String NameAddr))
    -> SourceDebDescription
    -> Const (Either String NameAddr) SourceDebDescription)
-> (Either String NameAddr
    -> Const (Either String NameAddr) (Either String NameAddr))
-> DebInfo
-> Const (Either String NameAddr) DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Either String NameAddr
 -> Const (Either String NameAddr) (Either String NameAddr))
-> SourceDebDescription
-> Const (Either String NameAddr) SourceDebDescription
Lens' SourceDebDescription (Either String NameAddr)
S.maintainer)
       let nameToUse :: Either String NameAddr
nameToUse | (NameAddr
n:[NameAddr]
_) <- [NameAddr]
debianUploaders = NameAddr -> Either String NameAddr
forall a b. b -> Either a b
Right NameAddr
n
                     | Bool
otherwise                = Either String 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 (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 String NameAddr
-> Text
-> Maybe ChangeLog
-> Maybe ChangeLog
fixLog Maybe SrcPkgName
src DebianVersion
ver Maybe [[Text]]
cmts Either String 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 String NameAddr
-> Text
-> Maybe ChangeLog
-> Maybe ChangeLog
fixLog Maybe SrcPkgName
src DebianVersion
ver Maybe [[Text]]
cmts Either String NameAddr
_maint Text
_ (Just (ChangeLog (ChangeLogEntry
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 :: String
logPackage = Doc -> String
forall a. Show a => a -> String
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))
                                 , logComments :: String
logComments = ChangeLogEntry -> String
logComments ChangeLogEntry
entry String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\n" String -> String -> String
forall a. [a] -> [a] -> [a]
++
                                                 ([String] -> String
List.unlines ([String] -> String) -> [String] -> String
forall a b. (a -> b) -> a -> b
$ ([Text] -> String) -> [[Text]] -> [String]
forall a b. (a -> b) -> [a] -> [b]
List.map ((String
"  * " String -> String -> String
forall a. Semigroup a => a -> a -> a
<>) (String -> String) -> ([Text] -> String) -> [Text] -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
List.intercalate String
"\n    " ([String] -> String) -> ([Text] -> [String]) -> [Text] -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
List.map Text -> String
unpack) ([[Text]] -> Maybe [[Text]] -> [[Text]]
forall a. a -> Maybe a -> a
fromMaybe [] Maybe [[Text]]
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))
      -- The newest log entry isn't exactly ver, build a new entry.
      fixLog Maybe SrcPkgName
src DebianVersion
ver Maybe [[Text]]
cmts Either String NameAddr
maint Text
msg Maybe ChangeLog
log =
          let entry :: ChangeLogEntry
entry = Entry :: String
-> DebianVersion
-> [Codename]
-> String
-> String
-> String
-> String
-> ChangeLogEntry
Entry { logPackage :: String
logPackage = Doc -> String
forall a. Show a => a -> String
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 = [String -> Codename
parseCodename String
"UNRELEASED"]
                                 , logUrgency :: String
logUrgency = String
"low"
                                 , logComments :: String
logComments =
                                     [String] -> String
List.unlines ([String] -> String) -> [String] -> String
forall a b. (a -> b) -> a -> b
$ ([Text] -> String) -> [[Text]] -> [String]
forall a b. (a -> b) -> [a] -> [b]
List.map ((String
"  * " String -> String -> String
forall a. Semigroup a => a -> a -> a
<>) (String -> String) -> ([Text] -> String) -> [Text] -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
List.intercalate String
"\n    " ([String] -> String) -> ([Text] -> [String]) -> [Text] -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
List.map Text -> String
unpack) ([[Text]] -> Maybe [[Text]] -> [[Text]]
forall a. a -> Maybe a -> a
fromMaybe [[Text
msg]] Maybe [[Text]]
cmts)
                                 , logWho :: String
logWho = (String -> String)
-> (NameAddr -> String) -> Either String NameAddr -> String
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\String
_ -> NameAddr -> String
forall a. Pretty (PP a) => a -> String
ppShow NameAddr
maintainerOfLastResort) NameAddr -> String
forall a. Pretty (PP a) => a -> String
ppShow Either String NameAddr
maint
                                 , logDate :: String
logDate = String
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 :: 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 String Relations
libMap <- Getting (Map String Relations) CabalInfo (Map String Relations)
-> StateT CabalInfo m (Map String Relations)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Map String Relations) DebInfo)
-> CabalInfo -> Const (Map String Relations) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Map String Relations) DebInfo)
 -> CabalInfo -> Const (Map String Relations) CabalInfo)
-> ((Map String Relations
     -> Const (Map String Relations) (Map String Relations))
    -> DebInfo -> Const (Map String Relations) DebInfo)
-> Getting (Map String Relations) CabalInfo (Map String Relations)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map String Relations
 -> Const (Map String Relations) (Map String Relations))
-> DebInfo -> Const (Map String Relations) DebInfo
Lens' DebInfo (Map String 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 String Relations -> Relations
g PackageDescription
pkgDesc Map String Relations
libMap)
    where
      g :: PackageDescription -> Map String Relations -> Relations
      g :: PackageDescription -> Map String Relations -> Relations
g PackageDescription
pkgDesc Map String Relations
libMap = (String -> Relations) -> [String] -> Relations
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Map String Relations -> String -> Relations
devDep Map String Relations
libMap) ([String] -> [String]
forall a. Eq a => [a] -> [a]
nub ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ (BuildInfo -> [String]) -> [BuildInfo] -> [String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap BuildInfo -> [String]
Cabal.extraLibs ([BuildInfo] -> [String]) -> [BuildInfo] -> [String]
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 String Relations -> String -> Relations
devDep Map String Relations
libMap String
cab = Relations
-> (Relations -> Relations) -> Maybe Relations -> Relations
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [[BinPkgName -> Maybe VersionReq -> Maybe ArchitectureReq -> Relation
Rel (String -> BinPkgName
BinPkgName (String
"lib" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
cab String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"-dev")) Maybe VersionReq
forall a. Maybe a
Nothing Maybe ArchitectureReq
forall a. Maybe a
Nothing]] Relations -> Relations
forall a. a -> a
id (String -> Map String Relations -> Maybe Relations
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup String
cab Map String Relations
libMap)

-- | Applies a few settings to official packages (unless already set)
checkOfficialSettings :: (Monad m) => CompilerFlavor -> CabalT m ()
checkOfficialSettings :: 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
_ -> String -> CabalT m ()
forall a. HasCallStack => String -> a
error (String -> CabalT m ()) -> String -> CabalT m ()
forall a b. (a -> b) -> a -> b
$ String
"There is no official packaging for " String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompilerFlavor -> String
forall a. Show a => a -> String
show CompilerFlavor
flavor

officialSettings :: (Monad m) => CabalT m ()
officialSettings :: 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 (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 = String -> a
forall a. HasCallStack => String -> a
error String
"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 String
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
<> String -> Text
pack String
src
        LensLike'
  (Zoomed (StateT SourceDebDescription m) ())
  DebInfo
  SourceDebDescription
-> StateT SourceDebDescription m () -> StateT DebInfo m ()
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 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
           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 (String -> StandardsVersion
parseStandardsVersion String
"4.6.1")
           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
<> String -> Text
pack (PackageName -> String
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"
              ])

putBuildDeps :: (MonadIO m) => (Relations -> Relations) -> PackageDescription -> CabalT m ()
putBuildDeps :: (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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Relations -> CabalT m Relations
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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Relations -> CabalT m Relations
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 (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 (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem BinPkgName
name [BinPkgName]
badNames)) [Relation]
rels

cabalExecBinaryPackage :: Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage :: 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 (String -> Section
MainSection String
"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 :: BinPkgName -> PackageType -> CabalT m ()
binaryPackageRelations BinPkgName
b PackageType
typ = LensLike' (Zoomed (StateT DebInfo m) ()) CabalInfo DebInfo
-> StateT DebInfo m () -> CabalT m ()
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
  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 (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 -> Focusing m () BinaryDebDescription)
 -> DebInfo -> Focusing m () DebInfo)
-> ((PackageRelations -> Focusing m () PackageRelations)
    -> BinaryDebDescription -> Focusing m () BinaryDebDescription)
-> (PackageRelations -> Focusing m () PackageRelations)
-> DebInfo
-> Focusing m () DebInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PackageRelations -> Focusing m () PackageRelations)
-> BinaryDebDescription -> Focusing 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 ()
%= (String -> [Relation]
anyrel String
"${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 ()
%= (String -> [Relation]
anyrel String
"${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 ()
%= ([String -> [Relation]
anyrel String
"${haskell:Depends}", String -> [Relation]
anyrel String
"${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 ()
%= (String -> [Relation]
anyrel String
"${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 ()
%= (String -> [Relation]
anyrel String
"${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 ()
%= (String -> [Relation]
anyrel String
"${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 ()
%= (String -> [Relation]
anyrel String
"${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 :: 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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Bool -> StateT CabalInfo m Bool
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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Bool -> StateT CabalInfo m Bool
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 :: 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 (String -> Section
MainSection String
"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 :: 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 :: 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 String)
installedDataMap <- (Atom
 -> Map BinPkgName (Set String) -> Map BinPkgName (Set String))
-> Map BinPkgName (Set String)
-> Set Atom
-> Map BinPkgName (Set String)
forall a b. (a -> b -> b) -> b -> Set a -> b
Set.fold (\ Atom
x Map BinPkgName (Set String)
r ->
                                         case Atom
x of
                                           D.Install BinPkgName
b String
src String
_ -> (Set String -> Set String -> Set String)
-> BinPkgName
-> Set String
-> Map BinPkgName (Set String)
-> Map BinPkgName (Set String)
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith Set String -> Set String -> Set String
forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b (String -> Set String
forall a. a -> Set a
singleton String
src) Map BinPkgName (Set String)
r
                                           D.InstallTo BinPkgName
b String
src String
_ -> (Set String -> Set String -> Set String)
-> BinPkgName
-> Set String
-> Map BinPkgName (Set String)
-> Map BinPkgName (Set String)
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith Set String -> Set String -> Set String
forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b (String -> Set String
forall a. a -> Set a
singleton String
src) Map BinPkgName (Set String)
r
                                           D.InstallData BinPkgName
b String
src  String
_ -> (Set String -> Set String -> Set String)
-> BinPkgName
-> Set String
-> Map BinPkgName (Set String)
-> Map BinPkgName (Set String)
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith Set String -> Set String -> Set String
forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b (String -> Set String
forall a. a -> Set a
singleton String
src) Map BinPkgName (Set String)
r
                                           Atom
_ -> Map BinPkgName (Set String)
r) Map BinPkgName (Set String)
forall a. Monoid a => a
mempty (Set Atom -> Map BinPkgName (Set String))
-> StateT CabalInfo m (Set Atom)
-> StateT CabalInfo m (Map BinPkgName (Set String))
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 String)
installedExecMap <- (Atom
 -> Map BinPkgName (Set String) -> Map BinPkgName (Set String))
-> Map BinPkgName (Set String)
-> Set Atom
-> Map BinPkgName (Set String)
forall a b. (a -> b -> b) -> b -> Set a -> b
Set.fold (\ Atom
x Map BinPkgName (Set String)
r ->
                                         case Atom
x of
                                           D.InstallCabalExec BinPkgName
b String
name String
_ -> (Set String -> Set String -> Set String)
-> BinPkgName
-> Set String
-> Map BinPkgName (Set String)
-> Map BinPkgName (Set String)
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith Set String -> Set String -> Set String
forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b (String -> Set String
forall a. a -> Set a
singleton String
name) Map BinPkgName (Set String)
r
                                           D.InstallCabalExecTo BinPkgName
b String
name String
_ -> (Set String -> Set String -> Set String)
-> BinPkgName
-> Set String
-> Map BinPkgName (Set String)
-> Map BinPkgName (Set String)
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith Set String -> Set String -> Set String
forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b (String -> Set String
forall a. a -> Set a
singleton String
name) Map BinPkgName (Set String)
r
                                           Atom
_ -> Map BinPkgName (Set String)
r) Map BinPkgName (Set String)
forall a. Monoid a => a
mempty (Set Atom -> Map BinPkgName (Set String))
-> StateT CabalInfo m (Set Atom)
-> StateT CabalInfo m (Map BinPkgName (Set String))
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 String
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 String))
-> StateT CabalInfo m (Set String)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Set String -> StateT CabalInfo m (Set String)
forall (m :: * -> *) a. Monad m => a -> m a
return (Set String -> StateT CabalInfo m (Set String))
-> (Map BinPkgName InstallFile -> Set String)
-> Map BinPkgName InstallFile
-> StateT CabalInfo m (Set String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (InstallFile -> String) -> Set InstallFile -> Set String
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map InstallFile -> String
ename (Set InstallFile -> Set String)
-> (Map BinPkgName InstallFile -> Set InstallFile)
-> Map BinPkgName InstallFile
-> Set String
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 (String, String)
installedData = (String -> (String, String)) -> Set String -> Set (String, String)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\ String
a -> (String
a, String
a)) (Set String -> Set (String, String))
-> Set String -> Set (String, String)
forall a b. (a -> b) -> a -> b
$ [Set String] -> Set String
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions (Map BinPkgName (Set String) -> [Set String]
forall k a. Map k a -> [a]
Map.elems Map BinPkgName (Set String)
installedDataMap)
           installedExec :: Set String
           installedExec :: Set String
installedExec = [Set String] -> Set String
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions (Map BinPkgName (Set String) -> [Set String]
forall k a. Map k a -> [a]
Map.elems Map BinPkgName (Set String)
installedExecMap)

       String
prefixPath <- CabalT m String
forall (m :: * -> *). Monad m => CabalT m String
dataTop
       let dataFilePaths :: Set (String, String)
dataFilePaths = [(String, String)] -> Set (String, String)
forall a. Ord a => [a] -> Set a
Set.fromList ([String] -> [String] -> [(String, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip ((String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
List.map (String
prefixPath String -> String -> String
</>) (PackageDescription -> [String]
Cabal.dataFiles PackageDescription
pkgDesc)) (PackageDescription -> [String]
Cabal.dataFiles PackageDescription
pkgDesc)) :: Set (FilePath, FilePath)
           execFilePaths :: Set FilePath
           execFilePaths :: Set String
execFilePaths = (Executable -> String) -> Set Executable -> Set String
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (UnqualComponentName -> String
unUnqualComponentName (UnqualComponentName -> String)
-> (Executable -> UnqualComponentName) -> Executable -> String
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 (String, String)
availableData = Set (String, String)
-> Set (String, String) -> Set (String, String)
forall a. Ord a => Set a -> Set a -> Set a
Set.union Set (String, String)
installedData Set (String, String)
dataFilePaths
           availableExec :: Set String
availableExec = Set String -> Set String -> Set String
forall a. Ord a => Set a -> Set a -> Set a
Set.union Set String
installedExec Set String
execFilePaths

       Getting (Maybe String) CabalInfo (Maybe String)
-> StateT CabalInfo m (Maybe String)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe String) DebInfo)
-> CabalInfo -> Const (Maybe String) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe String) DebInfo)
 -> CabalInfo -> Const (Maybe String) CabalInfo)
-> ((Maybe String -> Const (Maybe String) (Maybe String))
    -> DebInfo -> Const (Maybe String) DebInfo)
-> Getting (Maybe String) CabalInfo (Maybe String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe String -> Const (Maybe String) (Maybe String))
-> DebInfo -> Const (Maybe String) DebInfo
Lens' DebInfo (Maybe String)
D.utilsPackageNameBase) StateT CabalInfo m (Maybe String)
-> (Maybe String -> CabalT m ()) -> CabalT m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ Maybe String
name ->
           case Maybe String
name of
             Maybe String
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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ (BinPkgName String
name') -> ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Maybe String -> Identity (Maybe String))
    -> DebInfo -> Identity DebInfo)
-> (Maybe String -> Identity (Maybe String))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe String -> Identity (Maybe String))
-> DebInfo -> Identity DebInfo
Lens' DebInfo (Maybe String)
D.utilsPackageNameBase) ((Maybe String -> Identity (Maybe String))
 -> CabalInfo -> Identity CabalInfo)
-> Maybe String -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= String -> Maybe String
forall a. a -> Maybe a
Just String
name'
             Maybe String
_ -> () -> CabalT m ()
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 (String, String)
installedDataOther = (String -> (String, String)) -> Set String -> Set (String, String)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\ String
a -> (String
a, String
a)) (Set String -> Set (String, String))
-> Set String -> Set (String, String)
forall a b. (a -> b) -> a -> b
$ [Set String] -> Set String
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions ([Set String] -> Set String) -> [Set String] -> Set String
forall a b. (a -> b) -> a -> b
$ Map BinPkgName (Set String) -> [Set String]
forall k a. Map k a -> [a]
Map.elems (Map BinPkgName (Set String) -> [Set String])
-> Map BinPkgName (Set String) -> [Set String]
forall a b. (a -> b) -> a -> b
$ BinPkgName
-> Map BinPkgName (Set String) -> Map BinPkgName (Set String)
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete BinPkgName
b Map BinPkgName (Set String)
installedDataMap
           installedExecOther :: Set String
installedExecOther = Set String -> Set String -> Set String
forall a. Ord a => Set a -> Set a -> Set a
Set.union Set String
insExecPkg (Set String -> Set String) -> Set String -> Set String
forall a b. (a -> b) -> a -> b
$ [Set String] -> Set String
forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions ([Set String] -> Set String) -> [Set String] -> Set String
forall a b. (a -> b) -> a -> b
$ Map BinPkgName (Set String) -> [Set String]
forall k a. Map k a -> [a]
Map.elems (Map BinPkgName (Set String) -> [Set String])
-> Map BinPkgName (Set String) -> [Set String]
forall a b. (a -> b) -> a -> b
$ BinPkgName
-> Map BinPkgName (Set String) -> Map BinPkgName (Set String)
forall k a. Ord k => k -> Map k a -> Map k a
Map.delete BinPkgName
b Map BinPkgName (Set String)
installedExecMap

       -- Files that will be in utils packages
       let utilsData :: Set (String, String)
utilsData = Set (String, String)
-> Set (String, String) -> Set (String, String)
forall a. Ord a => Set a -> Set a -> Set a
Set.difference Set (String, String)
availableData Set (String, String)
installedDataOther
           utilsExec :: Set String
utilsExec = Set String -> Set String -> Set String
forall a. Ord a => Set a -> Set a -> Set a
Set.difference Set String
availableExec Set String
installedExecOther
       -- Files that still need to be assigned to the utils packages
       let utilsDataMissing :: Set (String, String)
utilsDataMissing = Set (String, String)
-> Set (String, String) -> Set (String, String)
forall a. Ord a => Set a -> Set a -> Set a
Set.difference Set (String, String)
utilsData Set (String, String)
installedData
           utilsExecMissing :: Set String
utilsExecMissing = Set String -> Set String -> Set String
forall a. Ord a => Set a -> Set a -> Set a
Set.difference Set String
utilsExec Set String
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 (String, String) -> Bool
forall a. Set a -> Bool
Set.null Set (String, String)
utilsData Bool -> Bool -> Bool
&& Set String -> Bool
forall a. Set a -> Bool
Set.null Set String
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 (String -> Text
pack (String
"build" String -> String -> String
</> BinPkgName -> String
forall a. Pretty (PP a) => a -> String
ppShow BinPkgName
b String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
":: 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 String -> Bool
forall a. Set a -> Bool
Set.null Set String
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 (String -> Section
MainSection String
"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
       ((String, String) -> CabalT m ())
-> Set (String, String) -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\ (String
foo, String
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 -> String -> String -> Atom
D.InstallData BinPkgName
b String
foo String
bar)) Set (String, String)
utilsDataMissing
       (String -> CabalT m ()) -> Set String -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\ String
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 -> String -> String -> Atom
D.InstallCabalExec BinPkgName
b String
name String
"usr/bin")) Set String
utilsExecMissing
    where
      ename :: InstallFile -> String
ename InstallFile
i =
          case InstallFile -> Maybe String
D.sourceDir InstallFile
i of
            Maybe String
Nothing -> InstallFile -> String
D.execName InstallFile
i
            Just String
s ->  String
s String -> String -> String
</> InstallFile -> String
D.execName InstallFile
i

expandAtoms :: Monad m => CabalT m () -> CabalT m ()
expandAtoms :: 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 (String -> [(FlagName, Bool)]
flagList String
"--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 (String -> [(FlagName, Bool)]
flagList String
"--ghcjs")))
         CompilerFlavor
x -> String -> CabalT m ()
forall a. HasCallStack => String -> a
error (String -> CabalT m ()) -> String -> CabalT m ()
forall a b. (a -> b) -> a -> b
$ String
"Sorry, compiler not supported: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompilerFlavor -> String
forall a. Show a => a -> String
show CompilerFlavor
x
       String
builddir <- Getting (Maybe String) CabalInfo (Maybe String)
-> StateT CabalInfo m (Maybe String)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use ((DebInfo -> Const (Maybe String) DebInfo)
-> CabalInfo -> Const (Maybe String) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Maybe String) DebInfo)
 -> CabalInfo -> Const (Maybe String) CabalInfo)
-> ((Maybe String -> Const (Maybe String) (Maybe String))
    -> DebInfo -> Const (Maybe String) DebInfo)
-> Getting (Maybe String) CabalInfo (Maybe String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe String -> Const (Maybe String) (Maybe String))
-> DebInfo -> Const (Maybe String) DebInfo
Lens' DebInfo (Maybe String)
D.buildDir) StateT CabalInfo m (Maybe String)
-> (Maybe String -> StateT CabalInfo m String)
-> StateT CabalInfo m String
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> StateT CabalInfo m String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> StateT CabalInfo m String)
-> (Maybe String -> String)
-> Maybe String
-> StateT CabalInfo m String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Maybe String -> String
forall a. a -> Maybe a -> a
fromMaybe (case CompilerFlavor
hc of
                                                               CompilerFlavor
GHC -> String
"dist-ghc/build"
                                                               CompilerFlavor
GHCJS -> String
"dist-ghcjs/build"
                                                               CompilerFlavor
_ -> String -> String
forall a. HasCallStack => String -> a
error (String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$ String
"Unexpected compiler: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompilerFlavor -> String
forall a. Show a => a -> String
show CompilerFlavor
hc)
       String
dDest <- StateT CabalInfo m String
forall (m :: * -> *). Monad m => CabalT m String
dataDest
       CabalT m ()
forall (m :: * -> *). Monad m => CabalT m ()
expandApacheSites
       String -> CabalT m ()
forall (m :: * -> *). Monad m => String -> CabalT m ()
expandInstallCabalExecs String
builddir
       String -> CabalT m ()
forall (m :: * -> *). Monad m => String -> CabalT m ()
expandInstallCabalExecTo String
builddir
       String -> CabalT m ()
forall (m :: * -> *). Monad m => String -> CabalT m ()
expandInstallData String
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 :: CabalT m ()
expandApacheSites =
          do Map BinPkgName (String, String, 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 (String, String, Text)))
-> StateT CabalInfo m (Map BinPkgName (String, String, Text))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Map BinPkgName (String, String, Text)
-> StateT CabalInfo m (Map BinPkgName (String, String, Text))
forall (m :: * -> *) a. Monad m => a -> m a
return (Map BinPkgName (String, String, Text)
 -> StateT CabalInfo m (Map BinPkgName (String, String, Text)))
-> (CabalInfo -> Map BinPkgName (String, String, Text))
-> CabalInfo
-> StateT CabalInfo m (Map BinPkgName (String, String, Text))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting
  (Map BinPkgName (String, String, Text))
  CabalInfo
  (Map BinPkgName (String, String, Text))
-> CabalInfo -> Map BinPkgName (String, String, Text)
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view ((DebInfo -> Const (Map BinPkgName (String, String, Text)) DebInfo)
-> CabalInfo
-> Const (Map BinPkgName (String, String, Text)) CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Const (Map BinPkgName (String, String, Text)) DebInfo)
 -> CabalInfo
 -> Const (Map BinPkgName (String, String, Text)) CabalInfo)
-> ((Map BinPkgName (String, String, Text)
     -> Const
          (Map BinPkgName (String, String, Text))
          (Map BinPkgName (String, String, Text)))
    -> DebInfo
    -> Const (Map BinPkgName (String, String, Text)) DebInfo)
-> Getting
     (Map BinPkgName (String, String, Text))
     CabalInfo
     (Map BinPkgName (String, String, Text))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map BinPkgName (String, String, Text)
 -> Const
      (Map BinPkgName (String, String, Text))
      (Map BinPkgName (String, String, Text)))
-> DebInfo -> Const (Map BinPkgName (String, String, Text)) DebInfo
Lens' DebInfo (Map BinPkgName (String, String, Text))
D.apacheSite)
             ((BinPkgName, (String, String, Text)) -> CabalT m ())
-> [(BinPkgName, (String, String, Text))] -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ (BinPkgName, (String, String, Text)) -> CabalT m ()
forall (m :: * -> *).
MonadState CabalInfo m =>
(BinPkgName, (String, String, Text)) -> m ()
expandApacheSite (Map BinPkgName (String, String, Text)
-> [(BinPkgName, (String, String, Text))]
forall k a. Map k a -> [(k, a)]
Map.toList Map BinPkgName (String, String, Text)
mp)
          where
            expandApacheSite :: (BinPkgName, (String, String, Text)) -> m ()
expandApacheSite (BinPkgName
b, (String
dom, String
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 -> String -> String -> Atom
D.Link BinPkgName
b (String
"/etc/apache2/sites-available/" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
dom) (String
"/etc/apache2/sites-enabled/" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
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 -> String -> Atom
D.InstallDir BinPkgName
b String
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 -> String -> Text -> Atom
D.File BinPkgName
b (String
"/etc/apache2/sites-available" String -> String -> String
</> String
dom) Text
text)

      -- Turn A.InstallCabalExec into A.Install
      expandInstallCabalExecs :: Monad m => FilePath -> CabalT m ()
      expandInstallCabalExecs :: String -> CabalT m ()
expandInstallCabalExecs String
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 (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 :: CompilerFlavor -> Atom -> CabalT m ()
doAtom CompilerFlavor
GHC (D.InstallCabalExec BinPkgName
b String
name String
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) -> 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 -> String -> String -> Atom
D.Install BinPkgName
b (String
builddir String -> String -> String
</> String
name String -> String -> String
</> String
name) String
dest)
            -- A GHCJS executable is a directory with files, copy them
            -- all into place.
            doAtom CompilerFlavor
GHCJS (D.InstallCabalExec BinPkgName
b String
name String
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) -> 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
                     ([Text] -> Text
Text.unlines
                        [ String -> Text
pack (String
"binary-fixup" String -> String -> String
</> BinPkgName -> String
forall a. Pretty (PP a) => a -> String
ppShow BinPkgName
b) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"::"
                        , String -> Text
pack (String
"\t(cd " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
builddir String -> String -> String
</> String
name String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
" && find -L " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
name String -> String -> String
<.> String
"jsexe" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
" -type f) |\\\n" String -> String -> String
forall a. Semigroup a => a -> a -> a
<>
                                       String
"\t  while read i; do install -Dp " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
builddir String -> String -> String
</> String
name String -> String -> String
</> String
"$$i debian" String -> String -> String
</> BinPkgName -> String
forall a. Pretty (PP a) => a -> String
ppShow BinPkgName
b String -> String -> String
</> String -> String -> String
makeRelative String
"/" String
dest String -> String -> String
</> String
"$$i; done\n") ])
            doAtom CompilerFlavor
_ Atom
_ = () -> CabalT m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

      -- Turn A.InstallCabalExecTo into a make rule
      expandInstallCabalExecTo :: Monad m => FilePath -> CabalT m ()
      expandInstallCabalExecTo :: String -> CabalT m ()
expandInstallCabalExecTo String
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 (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 :: CompilerFlavor -> Atom -> CabalT m ()
doAtom CompilerFlavor
GHC (D.InstallCabalExecTo BinPkgName
b String
name String
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) -> 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
                                     ([Text] -> Text
Text.unlines
                                       [ String -> Text
pack (String
"binary-fixup" String -> String -> String
</> BinPkgName -> String
forall a. Pretty (PP a) => a -> String
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
<> String -> Text
pack (String
builddir String -> String -> String
</> String
name String -> String -> String
</> String
name) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" "
                                                           Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
pack (String
"debian" String -> String -> String
</> BinPkgName -> String
forall a. Pretty (PP a) => a -> String
ppShow BinPkgName
b String -> String -> String
</> String -> String -> String
makeRelative String
"/" String
dest) ])
            doAtom CompilerFlavor
hc (D.InstallCabalExecTo BinPkgName
b String
name String
dest) = String -> CabalT m ()
forall a. HasCallStack => String -> a
error (String -> CabalT m ()) -> String -> CabalT m ()
forall a b. (a -> b) -> a -> b
$ String
"expandInstallCabalExecTo " String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompilerFlavor -> String
forall a. Show a => a -> String
show CompilerFlavor
hc String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Atom -> String
forall a. Show a => a -> String
show (BinPkgName -> String -> String -> Atom
D.InstallCabalExecTo BinPkgName
b String
name String
dest)
            doAtom CompilerFlavor
_ Atom
_ = () -> CabalT m ()
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 :: String -> CabalT m ()
expandInstallData String
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 -> CabalT m ()) -> CabalT m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Atom -> CabalT m ()) -> [Atom] -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ Atom -> CabalT m ()
forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom ([Atom] -> CabalT m ())
-> (Set Atom -> [Atom]) -> Set Atom -> CabalT 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 :: Atom -> CabalT m ()
doAtom (D.InstallData BinPkgName
b String
src String
dest) =
                if String -> String
takeFileName String
src String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String -> String
takeFileName String
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) -> 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 -> String -> String -> Atom
D.Install BinPkgName
b String
src (String
dDest String -> String -> String
</> String -> String -> String
makeRelative String
"/" (String -> String
takeDirectory String
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) -> 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 -> String -> String -> Atom
D.InstallTo BinPkgName
b String
src (String
dDest String -> String -> String
</> String -> String -> String
makeRelative String
"/" String
dest))
            doAtom Atom
_ = () -> CabalT m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

      -- Turn A.InstallTo into a make rule
      expandInstallTo :: Monad m => CabalT m ()
      expandInstallTo :: 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 -> CabalT m ()) -> CabalT m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Atom -> CabalT m ()) -> [Atom] -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ Atom -> CabalT m ()
forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom ([Atom] -> CabalT m ())
-> (Set Atom -> [Atom]) -> Set Atom -> CabalT 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 :: Atom -> CabalT m ()
doAtom (D.InstallTo BinPkgName
b String
src String
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) -> 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
                                    ([Text] -> Text
Text.unlines [ String -> Text
pack (String
"binary-fixup" String -> String -> String
</> BinPkgName -> String
forall a. Pretty (PP a) => a -> String
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
<> String -> Text
pack String
src Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
pack (String
"debian" String -> String -> String
</> BinPkgName -> String
forall a. Pretty (PP a) => a -> String
ppShow BinPkgName
b String -> String -> String
</> String -> String -> String
makeRelative String
"/" String
dest) ])
            doAtom Atom
_ = () -> CabalT m ()
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 :: 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 -> CabalT m ()) -> CabalT m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Atom -> CabalT m ()) -> [Atom] -> CabalT m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ Atom -> CabalT m ()
forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom ([Atom] -> CabalT m ())
-> (Set Atom -> [Atom]) -> Set Atom -> CabalT 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 :: Atom -> CabalT m ()
doAtom (D.File BinPkgName
b String
path Text
text) =
                do let (String
destDir', String
destName') = String -> (String, String)
splitFileName String
path
                       tmpDir :: String
tmpDir = String
"debian/cabalInstall" String -> String -> String
</> MD5Digest -> String
forall a. Show a => a -> String
show (ByteString -> MD5Digest
md5 (String -> ByteString
fromString (Text -> String
unpack Text
text)))
                       tmpPath :: String
tmpPath = String
tmpDir String -> String -> String
</> String
destName'
                   ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo
Lens' CabalInfo DebInfo
A.debInfo ((DebInfo -> Identity DebInfo) -> CabalInfo -> Identity CabalInfo)
-> ((Set (String, Text) -> Identity (Set (String, Text)))
    -> DebInfo -> Identity DebInfo)
-> (Set (String, Text) -> Identity (Set (String, Text)))
-> CabalInfo
-> Identity CabalInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set (String, Text) -> Identity (Set (String, Text)))
-> DebInfo -> Identity DebInfo
Lens' DebInfo (Set (String, Text))
D.intermediateFiles) ((Set (String, Text) -> Identity (Set (String, Text)))
 -> CabalInfo -> Identity CabalInfo)
-> (Set (String, Text) -> Set (String, Text)) -> CabalT m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (String, Text) -> Set (String, Text) -> Set (String, Text)
forall a. Ord a => a -> Set a -> Set a
Set.insert (String
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 -> String -> String -> Atom
D.Install BinPkgName
b String
tmpPath String
destDir')
            doAtom Atom
_ = () -> CabalT m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

      expandExecutable :: Monad m => CabalT m ()
      expandExecutable :: 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 (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Map BinPkgName InstallFile
-> StateT CabalInfo m (Map BinPkgName InstallFile)
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 :: CabalT m ()
finalizeRules =
    do DebBase String
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 (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 String
hcdeb = BinPkgName -> Maybe BinPkgName -> BinPkgName
forall a. a -> Maybe a -> a
fromMaybe (String -> BinPkgName
forall a. HasCallStack => String -> a
error String
"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
<> String -> Text
pack String
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
<> String -> Text
pack String
hcdeb])
       String
flags <- [(FlagName, Bool)] -> String
flagString ([(FlagName, Bool)] -> String)
-> (Set (FlagName, Bool) -> [(FlagName, Bool)])
-> Set (FlagName, Bool)
-> String
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) -> String)
-> StateT CabalInfo m (Set (FlagName, Bool))
-> StateT CabalInfo m String
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 (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null String
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
<> String -> Text
pack String
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
/= :: Dependency_ -> Dependency_ -> Bool
$c/= :: Dependency_ -> Dependency_ -> Bool
== :: Dependency_ -> Dependency_ -> Bool
$c== :: Dependency_ -> Dependency_ -> Bool
Eq, Int -> Dependency_ -> String -> String
[Dependency_] -> String -> String
Dependency_ -> String
(Int -> Dependency_ -> String -> String)
-> (Dependency_ -> String)
-> ([Dependency_] -> String -> String)
-> Show Dependency_
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Dependency_] -> String -> String
$cshowList :: [Dependency_] -> String -> String
show :: Dependency_ -> String
$cshow :: Dependency_ -> String
showsPrec :: Int -> Dependency_ -> String -> String
$cshowsPrec :: Int -> Dependency_ -> String -> String
Show)

anyrel :: String -> [D.Relation]
anyrel :: String -> [Relation]
anyrel String
x = BinPkgName -> [Relation]
anyrel' (String -> BinPkgName
D.BinPkgName String
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 :: String -> [(FlagName, Bool)]
flagList = (String -> (FlagName, Bool)) -> [String] -> [(FlagName, Bool)]
forall a b. (a -> b) -> [a] -> [b]
List.map String -> (FlagName, Bool)
tagWithValue ([String] -> [(FlagName, Bool)])
-> (String -> [String]) -> String -> [(FlagName, Bool)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> [String]
words
  where tagWithValue :: String -> (FlagName, Bool)
tagWithValue (Char
'-':String
name) = (String -> FlagName
mkFlagName ((Char -> Char) -> String -> String
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> Char
toLower String
name), Bool
False)
        tagWithValue String
name       = (String -> FlagName
mkFlagName ((Char -> Char) -> String -> String
forall a b. (a -> b) -> [a] -> [b]
List.map Char -> Char
toLower String
name), Bool
True)

flagString :: [(FlagName, Bool)] -> String
flagString :: [(FlagName, Bool)] -> String
flagString = [String] -> String
unwords ([String] -> String)
-> ([(FlagName, Bool)] -> [String]) -> [(FlagName, Bool)] -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((FlagName, Bool) -> String) -> [(FlagName, Bool)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
List.map (\ (FlagName
s, Bool
sense) -> String
"-f" String -> String -> String
forall a. [a] -> [a] -> [a]
++ (if Bool
sense then String
"" else String
"-") String -> String -> String
forall a. [a] -> [a] -> [a]
++ FlagName -> String
unFlagName FlagName
s)