-- | Compute the debianization of a cabal package.
{-# LANGUAGE CPP, FlexibleContexts, FlexibleInstances, OverloadedStrings, ScopedTypeVariables, TemplateHaskell #-}
module Debian.Debianize.Finalize
    ( debianize
    , debianizeWith
    , debianizeWebsite
    -- , finalizeDebianization -- external use deprecated - used in test script
    , watchAtom
    ) where


import Control.Lens hiding ((<.>))
import Control.Monad (unless, when)
import Control.Monad as List (mapM_)
import Control.Monad.State (get, modify)
import Control.Monad.Trans (liftIO, MonadIO)
import Data.ByteString.Lazy.UTF8 (fromString)
import Data.Char (isSpace, toLower)
import Data.Digest.Pure.MD5 (md5)
import Data.Function (on)
import Data.List as List (dropWhileEnd, filter, intercalate, map, nub, null, unlines, maximumBy)
import Data.Map as Map (delete, elems, insertWith, lookup, Map, toList)
import Data.Maybe (fromMaybe, isJust, fromJust)
import Data.Set as Set (difference, filter, fold, fromList, insert, map, null, Set, singleton, toList, union, unions)
import Data.Text as Text (intercalate, pack, Text, unlines, unpack)
import Debian.Changes (ChangeLog(..), ChangeLogEntry(..))
import Debian.Codename (parseCodename)
import Debian.Debianize.BasicInfo (cabalFlagAssignments, compilerFlavor, verbosity)
import qualified Debian.Debianize.BinaryDebDescription as B
import Debian.Debianize.BuildDependencies (debianBuildDeps, debianBuildDepsIndep)
import qualified Debian.Debianize.CabalInfo as A
import Debian.Debianize.Changelog (dropFutureEntries)
import qualified Debian.Debianize.DebInfo as D
import Debian.Debianize.DebianName (debianName, debianNameBase)
import Debian.Debianize.ExecAtoms (execAtoms)
import Debian.Debianize.Goodies (expandWebsite, expandServer, expandBackups)
import Debian.Debianize.InputDebian (dataTop, dataDest, inputChangeLog)
import Debian.Debianize.Monad as Monad (CabalT, liftCabal)
import Debian.Debianize.Prelude ((.?=), stripWith)
import qualified Debian.Debianize.SourceDebDescription as S
import Debian.Debianize.VersionSplits (DebBase(DebBase))
import Debian.GHC (compilerPackageName)
import Debian.Orphans ()
import Debian.Policy (getCurrentDebianUser, getDebhelperCompatLevel, haskellMaintainer, maintainerOfLastResort, PackageArchitectures(Any, All), PackagePriority(Optional), parseMaintainer, parseStandardsVersion, Section(..), SourceFormat(Native3))
import Debian.Pretty (PP(..), ppShow)
import Debian.Relation (BinPkgName, BinPkgName(BinPkgName), Relation(Rel), Relations, SrcPkgName(SrcPkgName))
import qualified Debian.Relation as D (BinPkgName(BinPkgName), Relation(..))
import Debian.Time (getCurrentLocalRFC822Time)
import qualified Debian.Version as V (buildDebianVersion, DebianVersion, parseDebianVersion', epoch, version, revision)
import Distribution.Compiler (CompilerFlavor(GHC))
import Distribution.Compiler (CompilerFlavor(GHCJS))
import Distribution.Package (Dependency(..), PackageIdentifier(..), PackageName, unPackageName)
import Distribution.PackageDescription as Cabal (allBuildInfo, author, BuildInfo(buildable, extraLibs), Executable(buildInfo, exeName), FlagName, mkFlagName, unFlagName, maintainer, PackageDescription(testSuites, description))
import Distribution.Types.UnqualComponentName
import Distribution.PackageDescription as Cabal (PackageDescription(dataFiles, {-description,-} executables, library, package, synopsis))
#if MIN_VERSION_Cabal(3,2,0)
import qualified Distribution.Utils.ShortText as ST
#endif
import Prelude hiding (init, log, map, unlines, unlines, writeFile)
import System.Directory (doesFileExist)
import System.FilePath ((<.>), (</>), makeRelative, splitFileName, takeDirectory, takeFileName)
import System.IO (hPutStrLn, stderr)
import Text.Parsec.Rfc2822 (NameAddr(..))
import Distribution.Pretty (Pretty(pretty))

-- | @debianize customize@ initializes the CabalT state from the
-- environment and the cabal package description in (and possibly the
-- debian/changelog file) from the current directory, then runs
-- @customize@ and finalizes the debianization so it is ready to be
-- output.
debianize :: (MonadIO m, MonadFail m) => CabalT m () -> CabalT m ()
debianize :: forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m ()
debianize = forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m () -> CabalT m ()
debianizeWith (forall (m :: * -> *) a. Monad m => a -> m a
return ())

debianizeWebsite :: (MonadIO m, MonadFail m) => CabalT m () -> CabalT m ()
debianizeWebsite :: forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m ()
debianizeWebsite = forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m () -> CabalT m ()
debianizeWith (forall (m :: * -> *). Monad m => CabalT m ()
expandWebsite forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => CabalT m ()
expandServer forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => CabalT m ()
expandBackups)

-- | Pass a function with some additional work to do.  I don't know
-- if this could be done by just summing it with customize - probably.
-- But I don't want to untangle this right now.
debianizeWith :: (MonadIO m, MonadFail m) => CabalT m () -> CabalT m () -> CabalT m ()
debianizeWith :: forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m () -> CabalT m ()
debianizeWith CabalT m ()
goodies CabalT m ()
customize =
  do forall (m :: * -> *) a.
Monad m =>
StateT DebInfo m a -> StateT CabalInfo m a
liftCabal forall (m :: * -> *). MonadIO m => DebianT m ()
inputChangeLog
     CabalT m ()
customize
     forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m ()
finalizeDebianization CabalT m ()
goodies

-- | Do some light IO and call finalizeDebianization.
finalizeDebianization :: (MonadIO m, MonadFail m) => CabalT m () -> CabalT m ()
finalizeDebianization :: forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m () -> CabalT m ()
finalizeDebianization CabalT m ()
goodies =
    do [Char]
date <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO [Char]
getCurrentLocalRFC822Time
       Maybe NameAddr
currentUser <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO (Maybe NameAddr)
getCurrentDebianUser
       Maybe Int
debhelperCompat <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO (Maybe Int)
getDebhelperCompatLevel
       Bool
setupExists <- forall (t :: * -> *). Foldable t => t Bool -> Bool
or forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> IO Bool
doesFileExist) [[Char]
"Setup.hs", [Char]
"Setup.lhs"]
       forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m ()
-> [Char] -> Maybe NameAddr -> Maybe Int -> Bool -> CabalT m ()
finalizeDebianization' CabalT m ()
goodies [Char]
date Maybe NameAddr
currentUser Maybe Int
debhelperCompat Bool
setupExists
       Int
vb <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Flags
D.flags forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Flags Int
verbosity)
       forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
vb forall a. Ord a => a -> a -> Bool
>= Int
3) (forall s (m :: * -> *). MonadState s m => m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ CabalInfo
x -> forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO ([Char] -> IO ()
putStrLn ([Char]
"\nFinalized Cabal Info: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show CabalInfo
x forall a. [a] -> [a] -> [a]
++ [Char]
"\n")))
       forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
e -> forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ Handle -> [Char] -> IO ()
hPutStrLn Handle
stderr ([Char]
"WARNING: " forall a. [a] -> [a] -> [a]
++ [Char]
e)) (\NameAddr
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return ()) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer)

-- | Now that we know the build and data directories, we can expand
-- some atoms into sets of simpler atoms which can eventually be
-- turned into the files of the debianization.  The original atoms are
-- not removed from the list because they may contribute to the
-- debianization in other ways, so be careful not to do this twice,
-- this function is not idempotent.  (Exported for use in unit tests.)
-- FIXME: we should be able to run this without a PackageDescription, change
--        paramter type to Maybe PackageDescription and propagate down thru code
finalizeDebianization' ::
    (MonadIO m, MonadFail m)
    => CabalT m ()
    -> String
    -> Maybe NameAddr
    -> Maybe Int
    -> Bool
    -> CabalT m ()
finalizeDebianization' :: forall (m :: * -> *).
(MonadIO m, MonadFail m) =>
CabalT m ()
-> [Char] -> Maybe NameAddr -> Maybe Int -> Bool -> CabalT m ()
finalizeDebianization' CabalT m ()
goodies [Char]
date Maybe NameAddr
currentUser Maybe Int
debhelperCompat Bool
setupExists =
    do -- In reality, hcs must be a singleton or many things won't work.  But some day...
       CompilerFlavor
hc <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Flags
D.flags forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Flags CompilerFlavor
compilerFlavor)
       PackageDescription
pkgDesc <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' CabalInfo PackageDescription
A.packageDescription

       TestsStatus
testsStatus <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo TestsStatus
D.testsStatus)
       let testsExist :: Bool
testsExist = Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null forall a b. (a -> b) -> a -> b
$ PackageDescription -> [TestSuite]
Cabal.testSuites PackageDescription
pkgDesc
       case (Bool
testsExist, TestsStatus
testsStatus) of
         (Bool
True, TestsStatus
D.TestsRun) -> (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo [Text]
D.rulesSettings) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. [a] -> [a] -> [a]
++ [Text
"DEB_ENABLE_TESTS = yes"])
         (Bool
True, TestsStatus
D.TestsBuild) -> (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo [Text]
D.rulesSettings) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. [a] -> [a] -> [a]
++ [Text
"DEB_ENABLE_TESTS = yes", Text
"DEB_BUILD_OPTIONS += nocheck"])
         (Bool, TestsStatus)
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo [Text]
D.rulesSettings) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%=
          (forall a. [a] -> [a] -> [a]
++ [Text
"DEB_SETUP_BIN_NAME = " forall a. Semigroup a => a -> a -> a
<> if Bool
setupExists then Text
"debian/hlibrary.setup" else Text
"cabal"])
 
       forall (m :: * -> *). Monad m => PackageType -> CabalT m ()
finalizeSourceName PackageType
B.HaskellSource
       forall (m :: * -> *). Monad m => CompilerFlavor -> CabalT m ()
checkOfficialSettings CompilerFlavor
hc
       forall (m :: * -> *). Monad m => CompilerFlavor -> CabalT m ()
addExtraLibDependencies CompilerFlavor
hc
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe Text)
D.watch) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just (PackageName -> Text
watchAtom (PackageIdentifier -> PackageName
pkgName forall a b. (a -> b) -> a -> b
$ PackageDescription -> PackageIdentifier
Cabal.package forall a b. (a -> b) -> a -> b
$ PackageDescription
pkgDesc))
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Maybe Section)
S.section) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just ([Char] -> Section
MainSection [Char]
"haskell")
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Maybe PackagePriority)
S.priority) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just PackagePriority
Optional
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe Int)
D.compat) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= Maybe Int
debhelperCompat
       forall (m :: * -> *).
Monad m =>
[Char] -> Maybe NameAddr -> CabalT m ()
finalizeChangelog [Char]
date Maybe NameAddr
currentUser
       forall (m :: * -> *). MonadFail m => Maybe NameAddr -> CabalT m ()
finalizeControl Maybe NameAddr
currentUser
       forall (m :: * -> *). MonadIO m => CabalT m ()
finalizeRules
       -- T.license .?= Just (Cabal.license pkgDesc)
       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
       forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Map BinPkgName InstallFile)
D.executable) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ (forall (m :: * -> *). Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Map k a -> [(k, a)]
Map.toList
       forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Map BinPkgName [Char])
D.backups) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ (forall (m :: * -> *). Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Map k a -> [(k, a)]
Map.toList
       forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Map BinPkgName Server)
D.serverInfo) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ (forall (m :: * -> *). Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Map k a -> [(k, a)]
Map.toList
       forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Map BinPkgName Site)
D.website) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ (forall (m :: * -> *). Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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.
       forall (m :: * -> *).
Monad m =>
PackageDescription -> CompilerFlavor -> CabalT m ()
librarySpecs PackageDescription
pkgDesc CompilerFlavor
hc
       forall (m :: * -> *).
Monad m =>
PackageDescription -> CompilerFlavor -> CabalT m ()
makeUtilsPackage PackageDescription
pkgDesc CompilerFlavor
hc
       [BinPkgName]
debs <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription [BinaryDebDescription]
S.binaryPackages) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
List.map (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BinaryDebDescription BinPkgName
B.package)
       Bool
allowSelfDeps <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Bool
D.allowDebianSelfBuildDeps)
       forall (m :: * -> *).
MonadIO m =>
(Relations -> Relations) -> PackageDescription -> CabalT m ()
putBuildDeps (if Bool
allowSelfDeps then 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.
       forall (m :: * -> *). Monad m => CabalT m () -> CabalT m ()
expandAtoms CabalT m ()
goodies
       -- Turn atoms related to priority, section, and description into debianization elements
       -- finalizeDescriptions

watchAtom :: PackageName -> Text
watchAtom :: PackageName -> Text
watchAtom PackageName
pkgname =
    [Char] -> Text
pack forall a b. (a -> b) -> a -> b
$ [Char]
"version=3\nhttps://hackage.haskell.org/package/" forall a. [a] -> [a] -> [a]
++ PackageName -> [Char]
unPackageName PackageName
pkgname forall a. [a] -> [a] -> [a]
++ [Char]
"/distro-monitor .*-([0-9\\.]+)\\.(?:zip|tgz|tbz|txz|(?:tar\\.(?:gz|bz2|xz)))\n"

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

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

-- | Construct the final Debian version number.
--  Inputs:
--
--    1. --deb-version argument
--    2. --revision argument
--    3. cabal version number
--    4. latest version in debian/changelog
--
-- The --deb-version argument overrides everything.
debianVersion :: (Monad m) => CabalT m V.DebianVersion
debianVersion :: forall (m :: * -> *). Monad m => CabalT m DebianVersion
debianVersion =
    do PackageName
cabalName <- (PackageIdentifier -> PackageName
pkgName forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageDescription -> PackageIdentifier
Cabal.package) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' CabalInfo PackageDescription
A.packageDescription
       (DebianVersion
cabalVersion :: V.DebianVersion) <- (forall string. ParseDebianVersion string => string -> DebianVersion
V.parseDebianVersion' forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Pretty (PP a) => a -> [Char]
ppShow forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageIdentifier -> Version
pkgVersion forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageDescription -> PackageIdentifier
Cabal.package) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' CabalInfo PackageDescription
A.packageDescription
       Maybe Int
cabalEpoch <- forall (m :: * -> *).
Monad m =>
PackageName -> CabalT m (Maybe Int)
debianEpoch PackageName
cabalName
       SourceFormat
fmt <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceFormat
D.sourceFormat)
       Maybe [Char]
cabalRevision <-
           do Maybe [Char]
x <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe [Char])
D.revision) -- from the --revision option
              let y :: Maybe [Char]
y = case Maybe [Char]
x of
                        Maybe [Char]
Nothing -> forall a. Maybe a
Nothing
                        Just [Char]
"" -> forall a. Maybe a
Nothing
                        Just [Char]
"-" -> forall a. Maybe a
Nothing
                        Just (Char
'-':[Char]
r) -> forall a. a -> Maybe a
Just [Char]
r
                        Just [Char]
_ -> forall a. HasCallStack => [Char] -> a
error [Char]
"The --revision argument must start with a dash"
              forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ case SourceFormat
fmt of
                         SourceFormat
Native3 -> Maybe [Char]
y
                         SourceFormat
_ -> forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall a. a -> Maybe a
Just [Char]
"1") (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => a -> a -> a
max [Char]
"1") Maybe [Char]
y
       Maybe DebianVersion
versionArg <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe DebianVersion)
D.debVersion) -- from the --deb-version option
       (Maybe DebianVersion
debVersion :: Maybe V.DebianVersion) <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe ChangeLog)
D.changelog) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall a. Maybe a
Nothing ChangeLog -> Maybe DebianVersion
changelogVersion

       case () of
         ()
_ | forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False (\ DebianVersion
v -> DebianVersion
v forall a. Ord a => a -> a -> Bool
< Maybe Int -> [Char] -> Maybe [Char] -> DebianVersion
V.buildDebianVersion Maybe Int
cabalEpoch (forall a. Pretty (PP a) => a -> [Char]
ppShow DebianVersion
cabalVersion) forall a. Maybe a
Nothing) Maybe DebianVersion
versionArg ->
               forall a. HasCallStack => [Char] -> a
error ([Char]
"Version from --deb-version (" forall a. [a] -> [a] -> [a]
++ forall a. Pretty (PP a) => a -> [Char]
ppShow Maybe DebianVersion
versionArg forall a. [a] -> [a] -> [a]
++
                      [Char]
") is older than cabal version (" forall a. [a] -> [a] -> [a]
++ forall a. Pretty (PP a) => a -> [Char]
ppShow DebianVersion
cabalVersion forall a. [a] -> [a] -> [a]
++
                      [Char]
"), maybe you need to unpin this package?")
         ()
_ | forall a. Maybe a -> Bool
isJust Maybe DebianVersion
versionArg -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. HasCallStack => Maybe a -> a
fromJust Maybe DebianVersion
versionArg
         ()
_ | forall a. Maybe a -> Bool
isJust Maybe DebianVersion
debVersion ->
               case (DebianVersion -> Maybe Int
V.epoch (forall a. HasCallStack => Maybe a -> a
fromJust Maybe DebianVersion
debVersion),
                     forall string. ParseDebianVersion string => string -> DebianVersion
V.parseDebianVersion' (DebianVersion -> [Char]
V.version (forall a. HasCallStack => Maybe a -> a
fromJust Maybe DebianVersion
debVersion)),
                     DebianVersion -> Maybe [Char]
V.revision (forall a. HasCallStack => Maybe a -> a
fromJust Maybe DebianVersion
debVersion)) of
                 (Maybe Int
debEpoch, DebianVersion
debianVersion', (Maybe [Char]
debianRevision :: Maybe String)) ->
                     let finalEpoch :: Maybe Int
finalEpoch = forall a. Ord a => a -> a -> a
max Maybe Int
debEpoch Maybe Int
cabalEpoch
                         finalVersion :: DebianVersion
finalVersion = forall a. Ord a => a -> a -> a
max DebianVersion
debianVersion' DebianVersion
cabalVersion
                         (Maybe [Char]
finalRevision :: Maybe String) = forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
maximumBy (forall a. Ord a => a -> a -> Ordering
compare forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall string. ParseDebianVersion string => string -> DebianVersion
V.parseDebianVersion') [Maybe [Char]
debianRevision, Maybe [Char]
cabalRevision] in
                     forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe Int -> [Char] -> Maybe [Char] -> DebianVersion
V.buildDebianVersion Maybe Int
finalEpoch (forall a. Pretty (PP a) => a -> [Char]
ppShow DebianVersion
finalVersion) Maybe [Char]
finalRevision
         ()
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Maybe Int -> [Char] -> Maybe [Char] -> DebianVersion
V.buildDebianVersion Maybe Int
cabalEpoch (forall a. Pretty (PP a) => a -> [Char]
ppShow DebianVersion
cabalVersion) Maybe [Char]
cabalRevision

changelogVersion :: ChangeLog -> Maybe V.DebianVersion
changelogVersion :: ChangeLog -> Maybe DebianVersion
changelogVersion (ChangeLog (Entry {logVersion :: ChangeLogEntry -> DebianVersion
logVersion = DebianVersion
x} : [ChangeLogEntry]
_)) = forall a. a -> Maybe a
Just DebianVersion
x
changelogVersion ChangeLog
_ = forall a. Maybe a
Nothing

-- | Return the Debian epoch number assigned to the given cabal
-- package - the 1 in version numbers like 1:3.5-2.
debianEpoch :: Monad m => PackageName -> CabalT m (Maybe Int)
debianEpoch :: forall (m :: * -> *).
Monad m =>
PackageName -> CabalT m (Maybe Int)
debianEpoch PackageName
name = forall s (m :: * -> *). MonadState s m => m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup PackageName
name forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' CabalInfo (Map PackageName Int)
A.epochMap

-- | Compute and return the debian source package name, based on the
-- sourcePackageName if it was specified, and constructed from the
-- cabal name otherwise.
finalizeSourceName :: (Monad m) => B.PackageType -> CabalT m ()
finalizeSourceName :: forall (m :: * -> *). Monad m => PackageType -> CabalT m ()
finalizeSourceName PackageType
typ =
    do DebBase [Char]
debName <- forall (m :: * -> *). Monad m => CabalT m DebBase
debianNameBase
       CompilerFlavor
hc <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Flags
D.flags forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Flags CompilerFlavor
compilerFlavor)
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe SrcPkgName)
D.sourcePackageName) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?=
          forall a. a -> Maybe a
Just ([Char] -> SrcPkgName
SrcPkgName (case (CompilerFlavor
hc, PackageType
typ) of
                              -- Haskell source deb names conventionally have the prefix
                              -- "haskell-" added.  Here we add prefix "ghcjs-" to
                              -- haskell packages build with the ghcjs compiler.
                              (CompilerFlavor
GHC, PackageType
B.HaskellSource) -> [Char]
"haskell-" forall a. [a] -> [a] -> [a]
++ [Char]
debName
                              (CompilerFlavor
GHCJS, PackageType
B.HaskellSource) -> [Char]
"ghcjs-" forall a. [a] -> [a] -> [a]
++ [Char]
debName
                              (CompilerFlavor
_, PackageType
B.Source) -> [Char]
debName
                              (CompilerFlavor, PackageType)
_ -> forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"finalizeSourceName: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show PackageType
typ))

-- | Try to compute a string for the the debian "Maintainer:" and
-- "Uploaders:" fields using, in this order
--    1. the Debian Haskell Group, @pkg-haskell-maintainers\@lists.alioth.debian.org@,
--       if --official is set
--    2. the maintainer explicitly specified using "Debian.Debianize.Monad.maintainer"
--    3. the maintainer field of the cabal package, but only if --official is not set,
--    4. the value returned by getDebianMaintainer, which looks in several environment variables,
--    5. the signature from the latest entry in debian/changelog,
--    6. the Debian Haskell Group, @pkg-haskell-maintainers\@lists.alioth.debian.org@
-- <http://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Maintainer>
-- <http://www.debian.org/doc/debian-policy/ch-controlfields.html#s-f-Uploaders>
finalizeMaintainer :: Monad m => Maybe NameAddr -> CabalT m ()
finalizeMaintainer :: forall (m :: * -> *). Monad m => Maybe NameAddr -> CabalT m ()
finalizeMaintainer Maybe NameAddr
currentUser = do
  Bool
o <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Bool
D.official)
  PackageDescription
pkgDesc <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' CabalInfo PackageDescription
A.packageDescription
  Maybe NameAddr
maintainerOption <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe NameAddr)
D.maintainerOption)
  [NameAddr]
uploadersOption <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo [NameAddr]
D.uploadersOption)
#if MIN_VERSION_Cabal(3,2,0)
  let toString :: ShortText -> [Char]
toString = ShortText -> [Char]
ST.fromShortText
#else
  let toString = id
#endif
      cabalAuthorString :: [Char]
cabalAuthorString = forall a. (a -> Bool) -> [a] -> [a]
takeWhile (\ Char
c -> Char
c forall a. Eq a => a -> a -> Bool
/= Char
',' Bool -> Bool -> Bool
&& Char
c forall a. Eq a => a -> a -> Bool
/= Char
'\n') (ShortText -> [Char]
toString (PackageDescription -> ShortText
Cabal.author PackageDescription
pkgDesc))
      cabalMaintainerString :: [Char]
cabalMaintainerString = forall a. (a -> Bool) -> [a] -> [a]
takeWhile (\ Char
c -> Char
c forall a. Eq a => a -> a -> Bool
/= Char
',' Bool -> Bool -> Bool
&& Char
c forall a. Eq a => a -> a -> Bool
/= Char
'\n') (ShortText -> [Char]
toString (PackageDescription -> ShortText
Cabal.maintainer PackageDescription
pkgDesc))
      cabalMaintainerString' :: [Char]
cabalMaintainerString' = [Char]
cabalAuthorString forall a. Semigroup a => a -> a -> a
<> [Char]
" <" forall a. Semigroup a => a -> a -> a
<> [Char]
cabalMaintainerString forall a. Semigroup a => a -> a -> a
<> [Char]
">"
      cabalMaintainerString'' :: [Char]
cabalMaintainerString'' = [Char]
cabalAuthorString forall a. Semigroup a => a -> a -> a
<> [Char]
" " forall a. Semigroup a => a -> a -> a
<> [Char]
cabalMaintainerString
  Maybe NameAddr
changelogSignature <-
      do Maybe ChangeLog
log <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe ChangeLog)
D.changelog)
         case Maybe ChangeLog
log of
           Just (ChangeLog (ChangeLogEntry
entry : [ChangeLogEntry]
_)) ->
               case ([Char] -> Either [Char] NameAddr
parseMaintainer (ChangeLogEntry -> [Char]
logWho ChangeLogEntry
entry)) of
                 Left [Char]
_e -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. Maybe a
Nothing -- Just $ NameAddr (Just "Invalid signature in changelog") (show e)
                 Right NameAddr
x -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just NameAddr
x)
           Maybe ChangeLog
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
  case Bool
o of
    Bool
True -> do
      (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= forall a b. b -> Either a b
Right NameAddr
haskellMaintainer
      (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription [NameAddr]
S.uploaders) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a. [a] -> [a] -> [a]
whenEmpty (forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (forall a. a -> [a] -> [a]
: []) Maybe NameAddr
currentUser)
    Bool
False -> do
      (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
x -> forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall a b. a -> Either a b
Left [Char]
x) forall a b. b -> Either a b
Right Maybe NameAddr
maintainerOption) forall a b. b -> Either a b
Right
      (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
_ -> [Char] -> Either [Char] NameAddr
parseMaintainer [Char]
cabalMaintainerString) forall a b. b -> Either a b
Right
      (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
_ -> [Char] -> Either [Char] NameAddr
parseMaintainer [Char]
cabalMaintainerString') forall a b. b -> Either a b
Right
      (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
_ -> [Char] -> Either [Char] NameAddr
parseMaintainer [Char]
cabalMaintainerString'') 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
      (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
e -> case [Char] -> Either [Char] NameAddr
parseMaintainer [Char]
cabalAuthorString of
                                                                Right NameAddr
x | NameAddr -> [Char]
nameAddr_addr NameAddr
x forall a. Eq a => a -> a -> Bool
== [Char]
cabalMaintainerString -> forall a b. b -> Either a b
Right NameAddr
x
                                                                Right NameAddr
_ -> forall a b. a -> Either a b
Left [Char]
e
                                                                Left [Char]
x -> forall a b. a -> Either a b
Left [Char]
x) forall a b. b -> Either a b
Right
      -- Sometimes the maintainer is just an email, try combining it with the author's name
      (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
e -> case [Char] -> Either [Char] NameAddr
parseMaintainer [Char]
cabalAuthorString of
                                                                Right (NameAddr {nameAddr_name :: NameAddr -> Maybe [Char]
nameAddr_name = Just [Char]
name}) -> [Char] -> Either [Char] NameAddr
parseMaintainer ([Char]
name forall a. [a] -> [a] -> [a]
++ [Char]
" <" forall a. [a] -> [a] -> [a]
++ [Char]
cabalMaintainerString forall a. [a] -> [a] -> [a]
++ [Char]
">")
                                                                Right NameAddr
_ -> forall a b. a -> Either a b
Left [Char]
e
                                                                Left [Char]
x -> forall a b. a -> Either a b
Left [Char]
x) forall a b. b -> Either a b
Right
      (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
e -> forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall a b. a -> Either a b
Left [Char]
e) forall a b. b -> Either a b
Right Maybe NameAddr
currentUser) forall a b. b -> Either a b
Right
      (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
e -> forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall a b. a -> Either a b
Left [Char]
e) forall a b. b -> Either a b
Right Maybe NameAddr
changelogSignature) forall a b. b -> Either a b
Right
      (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
_ -> forall a b. a -> Either a b
Left ([Char]
"Unable to construct a debian maintainer, using default.  Cabal maintainer strings tried:\n " forall a. [a] -> [a] -> [a]
++
                                                                    forall a. Show a => a -> [Char]
show [Char]
cabalMaintainerString forall a. [a] -> [a] -> [a]
++ [Char]
", " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show [Char]
cabalMaintainerString' forall a. [a] -> [a] -> [a]
++ [Char]
", " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show [Char]
cabalMaintainerString'' forall a. [a] -> [a] -> [a]
++
                                                                    [Char]
", currentUser: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Maybe NameAddr
currentUser)) forall a b. b -> Either a b
Right
      (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription [NameAddr]
S.uploaders) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a. [a] -> [a] -> [a]
whenEmpty [NameAddr]
uploadersOption

-- | If l is the empty list return d, otherwise return l.
whenEmpty :: [a] -> [a] -> [a]
whenEmpty :: forall a. [a] -> [a] -> [a]
whenEmpty [a]
d [] = [a]
d
whenEmpty [a]
_ [a]
l = [a]
l

finalizeControl :: (MonadFail m) => Maybe NameAddr -> CabalT m ()
finalizeControl :: forall (m :: * -> *). MonadFail m => Maybe NameAddr -> CabalT m ()
finalizeControl Maybe NameAddr
currentUser =
    do forall (m :: * -> *). Monad m => Maybe NameAddr -> CabalT m ()
finalizeMaintainer Maybe NameAddr
currentUser
       Just SrcPkgName
src <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe SrcPkgName)
D.sourcePackageName)
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Maybe SrcPkgName)
S.source) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= forall a. a -> Maybe a
Just SrcPkgName
src
       Text
desc' <- forall (m :: * -> *). Monad m => CabalT m Text
describe
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Maybe Text)
S.xDescription) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just Text
desc'
       -- control %= (\ y -> y { D.source = Just src, D.maintainer = Just maint })

describe :: Monad m => CabalT m Text
describe :: forall (m :: * -> *). Monad m => CabalT m Text
describe =
    do PackageDescription
p <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' CabalInfo PackageDescription
A.packageDescription
       forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
          PackageDescription -> Text
debianDescriptionBase PackageDescription
p {- <> "\n" <>
          case typ of
            Just B.Profiling ->
                Text.intercalate "\n"
                        [" .",
                         " This package provides a library for the Haskell programming language, compiled",
                         " for profiling.  See http:///www.haskell.org/ for more information on Haskell."]
            Just B.Development ->
                Text.intercalate "\n"
                        [" .",
                         " This package provides a library for the Haskell programming language.",
                         " See http:///www.haskell.org/ for more information on Haskell."]
            Just B.Documentation ->
                Text.intercalate "\n"
                        [" .",
                         " This package provides the documentation for a library for the Haskell",
                         " programming language.",
                         " See http:///www.haskell.org/ for more information on Haskell." ]
            Just B.Exec ->
                Text.intercalate "\n"
                        [" .",
                         " An executable built from the " <> pack (display (pkgName (Cabal.package p))) <> " package."]
      {-    ServerPackage ->
                Text.intercalate "\n"
                        [" .",
                         " A server built from the " <> pack (display (pkgName pkgId)) <> " package."] -}
            _ {-Utilities-} ->
                Text.intercalate "\n"
                        [" .",
                         " Files associated with the " <> pack (display (pkgName (Cabal.package p))) <> " package."]
            -- x -> error $ "Unexpected library package name suffix: " ++ show x
-}

-- | The Cabal package has one synopsis and one description field
-- for the entire package, while in a Debian package there is a
-- description field (of which the first line is synopsis) in
-- each binary package.  So the cabal description forms the base
-- of the debian description, each of which is amended.
debianDescriptionBase :: PackageDescription -> Text
debianDescriptionBase :: PackageDescription -> Text
debianDescriptionBase PackageDescription
p =
    [Char] -> Text
pack forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [[a]] -> [a]
List.intercalate [Char]
"\n " forall a b. (a -> b) -> a -> b
$ ([Char]
synop' forall a. a -> [a] -> [a]
: [[Char]]
desc')
    where
      -- If we have a one line description and no synopsis, use
      -- the description as the synopsis.
      synop' :: [Char]
synop' = if forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null [Char]
synop Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Int
length [[Char]]
desc' forall a. Eq a => a -> a -> Bool
/= Int
1
               then [Char]
"WARNING: No synopsis available for package " forall a. [a] -> [a] -> [a]
++ forall a. Pretty (PP a) => a -> [Char]
ppShow (PackageDescription -> PackageIdentifier
package PackageDescription
p)
               else [Char]
synop
      synop :: String
      -- I don't know why (unwords . words) was applied here.  Maybe I'll find out when
      -- this version goes into production.  :-/  Ok, now I know, because sometimes the
      -- short cabal description has more than one line.
      synop :: [Char]
synop = forall a. [a] -> [[a]] -> [a]
List.intercalate [Char]
" " forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. (a -> Bool) -> [a] -> [a]
dropWhileEnd Char -> Bool
isSpace) forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
lines forall a b. (a -> b) -> a -> b
$ ShortText -> [Char]
toString forall a b. (a -> b) -> a -> b
$ PackageDescription -> ShortText
synopsis PackageDescription
p
      desc' :: [String]
      desc' :: [[Char]]
desc' = forall a b. (a -> b) -> [a] -> [b]
List.map forall {t :: * -> *} {a}.
(Foldable t, IsString (t a)) =>
t a -> t a
addDot forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> [a] -> [a]
stripWith forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. (a -> Bool) -> [a] -> [a]
dropWhileEnd Char -> Bool
isSpace) forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]]
lines forall a b. (a -> b) -> a -> b
$ ShortText -> [Char]
toString forall a b. (a -> b) -> a -> b
$ PackageDescription -> ShortText
Cabal.description PackageDescription
p
      addDot :: t a -> t a
addDot t a
line = if forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null t a
line then t a
"." else t a
line
#if MIN_VERSION_Cabal(3,2,0)
      toString :: ShortText -> [Char]
toString = ShortText -> [Char]
ST.fromShortText
#else
      toString = id
#endif

-- | Make sure there is a changelog entry with the version number and
-- source package name implied by the debianization.  This means
-- either adding an entry or modifying the latest entry (if its
-- version number is the exact one in our debianization.)
finalizeChangelog :: (Monad m) => String -> Maybe NameAddr -> CabalT m ()
finalizeChangelog :: forall (m :: * -> *).
Monad m =>
[Char] -> Maybe NameAddr -> CabalT m ()
finalizeChangelog [Char]
date Maybe NameAddr
currentUser =
    do forall (m :: * -> *). Monad m => Maybe NameAddr -> CabalT m ()
finalizeMaintainer Maybe NameAddr
currentUser
       DebianVersion
ver <- forall (m :: * -> *). Monad m => CabalT m DebianVersion
debianVersion
       Maybe SrcPkgName
src <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe SrcPkgName)
D.sourcePackageName)
       [NameAddr]
debianUploaders  <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription [NameAddr]
S.uploaders)
       Either [Char] NameAddr
debianMaintainer <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer)
       let nameToUse :: Either [Char] NameAddr
nameToUse | (NameAddr
n:[NameAddr]
_) <- [NameAddr]
debianUploaders = forall a b. b -> Either a b
Right NameAddr
n
                     | Bool
otherwise                = Either [Char] NameAddr
debianMaintainer
       -- pkgDesc <- use T.packageDescription >>= return . maybe Nothing (either Nothing Just . parseMaintainer . Cabal.maintainer)
       Maybe [[Text]]
cmts <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe [[Text]])
D.comments)
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe ChangeLog)
D.changelog) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= 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"
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe ChangeLog)
D.changelog) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= Maybe SrcPkgName
-> DebianVersion
-> Maybe [[Text]]
-> Either [Char] NameAddr
-> Text
-> Maybe ChangeLog
-> Maybe ChangeLog
fixLog Maybe SrcPkgName
src DebianVersion
ver Maybe [[Text]]
cmts Either [Char] NameAddr
nameToUse Text
msg
    where
      fixLog :: Maybe SrcPkgName -> V.DebianVersion -> Maybe [[Text]] -> Either String NameAddr -> Text -> Maybe ChangeLog -> Maybe ChangeLog
      -- Ensure that the package name is correct in the first log entry.
      fixLog :: Maybe SrcPkgName
-> DebianVersion
-> Maybe [[Text]]
-> Either [Char] NameAddr
-> Text
-> Maybe ChangeLog
-> Maybe ChangeLog
fixLog Maybe SrcPkgName
src DebianVersion
ver Maybe [[Text]]
cmts Either [Char] NameAddr
_maint Text
_ (Just (ChangeLog (ChangeLogEntry
entry : [ChangeLogEntry]
older)))
          | ChangeLogEntry -> DebianVersion
logVersion ChangeLogEntry
entry forall a. Eq a => a -> a -> Bool
== DebianVersion
ver =
              let entry' :: ChangeLogEntry
entry' = ChangeLogEntry
entry { logPackage :: [Char]
logPackage = forall a. Show a => a -> [Char]
show (forall a. Pretty a => a -> Doc
pretty (forall a. a -> PP a
PP Maybe SrcPkgName
src))
                                 , logComments :: [Char]
logComments = ChangeLogEntry -> [Char]
logComments ChangeLogEntry
entry forall a. [a] -> [a] -> [a]
++ [Char]
"\n" forall a. [a] -> [a] -> [a]
++
                                                 ([[Char]] -> [Char]
List.unlines forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
List.map (([Char]
"  * " forall a. Semigroup a => a -> a -> a
<>) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [[a]] -> [a]
List.intercalate [Char]
"\n    " forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
List.map Text -> [Char]
unpack) (forall a. a -> Maybe a -> a
fromMaybe [] Maybe [[Text]]
cmts))
                                 } in
              forall a. a -> Maybe a
Just ([ChangeLogEntry] -> ChangeLog
ChangeLog (ChangeLogEntry
entry' forall a. a -> [a] -> [a]
: [ChangeLogEntry]
older))
      -- The newest log entry isn't exactly ver, build a new entry.
      fixLog Maybe SrcPkgName
src DebianVersion
ver Maybe [[Text]]
cmts Either [Char] NameAddr
maint Text
msg Maybe ChangeLog
log =
          let entry :: ChangeLogEntry
entry = Entry { logPackage :: [Char]
logPackage = forall a. Show a => a -> [Char]
show (forall a. Pretty a => a -> Doc
pretty (forall a. a -> PP a
PP Maybe SrcPkgName
src))
                                 , logVersion :: DebianVersion
logVersion = DebianVersion
ver
                                 , logDists :: [Codename]
logDists = [[Char] -> Codename
parseCodename [Char]
"UNRELEASED"]
                                 , logUrgency :: [Char]
logUrgency = [Char]
"low"
                                 , logComments :: [Char]
logComments =
                                     [[Char]] -> [Char]
List.unlines forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
List.map (([Char]
"  * " forall a. Semigroup a => a -> a -> a
<>) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [[a]] -> [a]
List.intercalate [Char]
"\n    " forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
List.map Text -> [Char]
unpack) (forall a. a -> Maybe a -> a
fromMaybe [[Text
msg]] Maybe [[Text]]
cmts)
                                 , logWho :: [Char]
logWho = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (\[Char]
_ -> forall a. Pretty (PP a) => a -> [Char]
ppShow NameAddr
maintainerOfLastResort) forall a. Pretty (PP a) => a -> [Char]
ppShow Either [Char] NameAddr
maint
                                 , logDate :: [Char]
logDate = [Char]
date } in
          -- Creating new log entry for version
          forall a. a -> Maybe a
Just ([ChangeLogEntry] -> ChangeLog
ChangeLog (ChangeLogEntry
entry forall a. a -> [a] -> [a]
: forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\ (ChangeLog [ChangeLogEntry]
entries) -> [ChangeLogEntry]
entries) Maybe ChangeLog
log))

-- | Convert the extraLibs field of the cabal build info into debian
-- binary package names and make them dependendencies of the debian
-- devel package (if there is one.)
addExtraLibDependencies :: (Monad m) => CompilerFlavor -> CabalT m ()
addExtraLibDependencies :: forall (m :: * -> *). Monad m => CompilerFlavor -> CabalT m ()
addExtraLibDependencies CompilerFlavor
hc =
    do PackageDescription
pkgDesc <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' CabalInfo PackageDescription
A.packageDescription
       BinPkgName
devName <- forall (m :: * -> *) name.
(Monad m, PkgName name) =>
PackageType -> CompilerFlavor -> CabalT m name
debianName PackageType
B.Development CompilerFlavor
hc
       Map [Char] Relations
libMap <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Map [Char] Relations)
D.extraLibMap)
       [BinPkgName]
binNames <- forall a b. (a -> b) -> [a] -> [b]
List.map (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BinaryDebDescription BinPkgName
B.package) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription [BinaryDebDescription]
S.binaryPackages)
       forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (forall a. Eq a => a -> a -> Bool
== BinPkgName
devName) [BinPkgName]
binNames) ((Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
devName forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription PackageRelations
B.relations forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' PackageRelations Relations
B.depends) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= \ Relations
deps -> Relations
deps forall a. [a] -> [a] -> [a]
++ PackageDescription -> Map [Char] Relations -> Relations
g PackageDescription
pkgDesc Map [Char] Relations
libMap)
    where
      g :: PackageDescription -> Map String Relations -> Relations
      g :: PackageDescription -> Map [Char] Relations -> Relations
g PackageDescription
pkgDesc Map [Char] Relations
libMap = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Map [Char] Relations -> [Char] -> Relations
devDep Map [Char] Relations
libMap) (forall a. Eq a => [a] -> [a]
nub forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap BuildInfo -> [[Char]]
Cabal.extraLibs forall a b. (a -> b) -> a -> b
$ PackageDescription -> [BuildInfo]
Cabal.allBuildInfo forall a b. (a -> b) -> a -> b
$ PackageDescription
pkgDesc)
      devDep :: Map String Relations -> String -> Relations
      devDep :: Map [Char] Relations -> [Char] -> Relations
devDep Map [Char] Relations
libMap [Char]
cab = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [[BinPkgName -> Maybe VersionReq -> Maybe ArchitectureReq -> Relation
Rel ([Char] -> BinPkgName
BinPkgName ([Char]
"lib" forall a. [a] -> [a] -> [a]
++ [Char]
cab forall a. [a] -> [a] -> [a]
++ [Char]
"-dev")) forall a. Maybe a
Nothing forall a. Maybe a
Nothing]] forall a. a -> a
id (forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup [Char]
cab Map [Char] Relations
libMap)

-- | Applies a few settings to official packages (unless already set)
checkOfficialSettings :: (Monad m) => CompilerFlavor -> CabalT m ()
checkOfficialSettings :: forall (m :: * -> *). Monad m => CompilerFlavor -> CabalT m ()
checkOfficialSettings CompilerFlavor
flavor =
    do Bool
o <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Bool
D.official)
       forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
o forall a b. (a -> b) -> a -> b
$ case CompilerFlavor
flavor of
                  CompilerFlavor
GHC -> forall (m :: * -> *). Monad m => CabalT m ()
officialSettings
                  CompilerFlavor
_ -> forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"There is no official packaging for " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show CompilerFlavor
flavor

officialSettings :: (Monad m) => CabalT m ()
officialSettings :: forall (m :: * -> *). Monad m => CabalT m ()
officialSettings = do
    PackageDescription
pkgDesc <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' CabalInfo PackageDescription
A.packageDescription
    let cabal :: PackageName
cabal = PackageIdentifier -> PackageName
pkgName (PackageDescription -> PackageIdentifier
Cabal.package PackageDescription
pkgDesc)
    forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom Lens' CabalInfo DebInfo
A.debInfo forall a b. (a -> b) -> a -> b
$ do
        let officialError :: a
officialError = forall a. HasCallStack => [Char] -> a
error [Char]
"officialSettings: no sourcePackageName"

        Lens' DebInfo Bool
D.omitProfVersionDeps forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Bool
True
        SrcPkgName [Char]
src <- forall a. a -> Maybe a -> a
fromMaybe forall {a}. a
officialError forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Maybe SrcPkgName)
D.sourcePackageName

        let packagesURI :: Text
packagesURI = Text
"https://salsa.debian.org/haskell-team/DHG_packages/tree/master/p/" forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
src
        forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom Lens' DebInfo SourceDebDescription
D.control forall a b. (a -> b) -> a -> b
$ do
           Lens' SourceDebDescription (Maybe StandardsVersion)
S.standardsVersion forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just ([Char] -> StandardsVersion
parseStandardsVersion [Char]
"4.6.1")
           Lens' SourceDebDescription (Maybe Text)
S.homepage forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just (Text
"https://hackage.haskell.org/package/" forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack (PackageName -> [Char]
unPackageName PackageName
cabal))
           Lens' SourceDebDescription (Set VersionControlSpec)
S.vcsFields forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a. Ord a => Set a -> Set a -> Set a
Set.union (forall a. Ord a => [a] -> Set a
Set.fromList
              [ Text -> VersionControlSpec
S.VCSBrowser Text
packagesURI
              , Text -> VersionControlSpec
S.VCSGit (Text
"https://salsa.debian.org/haskell-team/DHG_packages.git [p/" forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
src forall a. Semigroup a => a -> a -> a
<> Text
"]")
              ])

putBuildDeps :: (MonadIO m) => (Relations -> Relations) -> PackageDescription -> CabalT m ()
putBuildDeps :: forall (m :: * -> *).
MonadIO m =>
(Relations -> Relations) -> PackageDescription -> CabalT m ()
putBuildDeps Relations -> Relations
finalizeRelations PackageDescription
pkgDesc =
    do Relations
deps <- forall (m :: * -> *).
MonadIO m =>
PackageDescription -> CabalT m Relations
debianBuildDeps PackageDescription
pkgDesc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relations -> Relations
finalizeRelations
       Relations
depsIndep <- forall (m :: * -> *).
MonadIO m =>
PackageDescription -> CabalT m Relations
debianBuildDepsIndep PackageDescription
pkgDesc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relations -> Relations
finalizeRelations
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription Relations
S.buildDepends) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Relations
deps
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo SourceDebDescription
D.control forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' SourceDebDescription Relations
S.buildDependsIndep) 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 =
    forall a. (a -> Bool) -> [a] -> [a]
List.filter (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null) (forall a b. (a -> b) -> [a] -> [b]
List.map [Relation] -> [Relation]
filterOrRelation Relations
orRels)
    where
      filterOrRelation :: [Relation] -> [Relation]
      filterOrRelation :: [Relation] -> [Relation]
filterOrRelation [Relation]
rels = forall a. (a -> Bool) -> [a] -> [a]
List.filter (\ (Rel BinPkgName
name Maybe VersionReq
_ Maybe ArchitectureReq
_) -> Bool -> Bool
not (forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem BinPkgName
name [BinPkgName]
badNames)) [Relation]
rels

cabalExecBinaryPackage :: Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage :: forall (m :: * -> *). Monad m => BinPkgName -> CabalT m ()
cabalExecBinaryPackage BinPkgName
b =
    do (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe PackageType)
B.packageType) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just PackageType
B.Exec
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe PackageArchitectures)
B.architecture) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just PackageArchitectures
Any
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe Section)
B.binarySection) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just ([Char] -> Section
MainSection [Char]
"misc")
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe Text)
B.description) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just Text
desc -- yeah, this same line is all over the place.
       forall (m :: * -> *).
Monad m =>
BinPkgName -> PackageType -> CabalT m ()
binaryPackageRelations BinPkgName
b PackageType
B.Exec
    where

binaryPackageRelations :: Monad m => BinPkgName -> B.PackageType -> CabalT m ()
binaryPackageRelations :: forall (m :: * -> *).
Monad m =>
BinPkgName -> PackageType -> CabalT m ()
binaryPackageRelations BinPkgName
b PackageType
typ = forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom Lens' CabalInfo DebInfo
A.debInfo forall a b. (a -> b) -> a -> b
$ do
  Relations
edds <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo Relations
D.extraDevDeps
  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 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription PackageRelations
B.relations) forall a b. (a -> b) -> a -> b
$ do
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (PackageType
typ forall a. Eq a => a -> a -> Bool
== PackageType
B.Development) forall a b. (a -> b) -> a -> b
$ do
      Lens' PackageRelations Relations
B.depends forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Relations
edds forall a. [a] -> [a] -> [a]
++)
      Lens' PackageRelations Relations
B.depends forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> [Relation]
anyrel [Char]
"${shlibs:Depends}" forall a. a -> [a] -> [a]
: )
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (PackageType
typ forall a. Eq a => a -> a -> Bool
== PackageType
B.Utilities) forall a b. (a -> b) -> a -> b
$
      Lens' PackageRelations Relations
B.depends forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> [Relation]
anyrel [Char]
"${shlibs:Depends}" forall a. a -> [a] -> [a]
: )
    Lens' PackageRelations Relations
B.depends    forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([[Char] -> [Relation]
anyrel [Char]
"${haskell:Depends}", [Char] -> [Relation]
anyrel [Char]
"${misc:Depends}"] forall a. [a] -> [a] -> [a]
++)
    Lens' PackageRelations Relations
B.recommends forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> [Relation]
anyrel [Char]
"${haskell:Recommends}" forall a. a -> [a] -> [a]
: )
    Lens' PackageRelations Relations
B.suggests   forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> [Relation]
anyrel [Char]
"${haskell:Suggests}" forall a. a -> [a] -> [a]
:)
    Lens' PackageRelations Relations
B.conflicts  forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> [Relation]
anyrel [Char]
"${haskell:Conflicts}" forall a. a -> [a] -> [a]
:)
    Lens' PackageRelations Relations
B.preDepends forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= []
    Lens' PackageRelations Relations
B.breaks     forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= []
    Lens' PackageRelations Relations
B.builtUsing forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= []

    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (PackageType
typ forall a. Eq a => a -> a -> Bool
== PackageType
B.Documentation) forall a b. (a -> b) -> a -> b
$ Lens' PackageRelations Relations
B.provides forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= ([Char] -> [Relation]
anyrel [Char]
"${haskell:Provides}" forall a. a -> [a] -> [a]
:)

-- | Add the library paragraphs for a particular compiler flavor.
librarySpecs :: (Monad m) => PackageDescription -> CompilerFlavor -> CabalT m ()
librarySpecs :: forall (m :: * -> *).
Monad m =>
PackageDescription -> CompilerFlavor -> CabalT m ()
librarySpecs PackageDescription
pkgDesc CompilerFlavor
hc =
    do let dev :: Bool
dev = forall a. Maybe a -> Bool
isJust (PackageDescription -> Maybe Library
Cabal.library PackageDescription
pkgDesc)
       Bool
doc <- forall s (m :: * -> *). MonadState s m => m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Bool
D.noDocumentationLibrary)
       Bool
prof <- forall s (m :: * -> *). MonadState s m => m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Bool
D.noProfilingLibrary)
       forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
dev (forall (m :: * -> *).
Monad m =>
PackageArchitectures
-> PackageType -> CompilerFlavor -> CabalT m ()
librarySpec PackageArchitectures
Any PackageType
B.Development CompilerFlavor
hc)
       forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
dev Bool -> Bool -> Bool
&& Bool
prof Bool -> Bool -> Bool
&& CompilerFlavor
hc forall a. Eq a => a -> a -> Bool
== CompilerFlavor
GHC) (forall (m :: * -> *).
Monad m =>
PackageArchitectures
-> PackageType -> CompilerFlavor -> CabalT m ()
librarySpec PackageArchitectures
Any PackageType
B.Profiling CompilerFlavor
hc)
       forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool
dev Bool -> Bool -> Bool
&& Bool
doc) (forall (m :: * -> *). Monad m => CompilerFlavor -> CabalT m ()
docSpecsParagraph CompilerFlavor
hc)

docSpecsParagraph :: (Monad m) => CompilerFlavor -> CabalT m ()
docSpecsParagraph :: forall (m :: * -> *). Monad m => CompilerFlavor -> CabalT m ()
docSpecsParagraph CompilerFlavor
hc =
    do BinPkgName
b <- forall (m :: * -> *) name.
(Monad m, PkgName name) =>
PackageType -> CompilerFlavor -> CabalT m name
debianName PackageType
B.Documentation CompilerFlavor
hc
       forall (m :: * -> *).
Monad m =>
BinPkgName -> PackageType -> CabalT m ()
binaryPackageRelations BinPkgName
b PackageType
B.Documentation
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe PackageType)
B.packageType) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just PackageType
B.Documentation
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe PackageType)
B.packageType) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just PackageType
B.Documentation
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe PackageArchitectures)
B.architecture) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= forall a. a -> Maybe a
Just PackageArchitectures
All
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe Section)
B.binarySection) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just ([Char] -> Section
MainSection [Char]
"doc")
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe Text)
B.description) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just Text
desc

librarySpec :: (Monad m) => PackageArchitectures -> B.PackageType -> CompilerFlavor -> CabalT m ()
librarySpec :: forall (m :: * -> *).
Monad m =>
PackageArchitectures
-> PackageType -> CompilerFlavor -> CabalT m ()
librarySpec PackageArchitectures
arch PackageType
typ CompilerFlavor
hc =
    do BinPkgName
b <- forall (m :: * -> *) name.
(Monad m, PkgName name) =>
PackageType -> CompilerFlavor -> CabalT m name
debianName PackageType
typ CompilerFlavor
hc
       forall (m :: * -> *).
Monad m =>
BinPkgName -> PackageType -> CabalT m ()
binaryPackageRelations BinPkgName
b PackageType
typ
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe PackageType)
B.packageType) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just PackageType
typ
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe PackageType)
B.packageType) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just PackageType
typ
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe PackageArchitectures)
B.architecture) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just PackageArchitectures
arch
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe Text)
B.description) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just Text
desc

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

-- | Make sure all data and executable files are assigned to at least
-- one binary package and make sure all binary packages are in the
-- package list in the source deb description.  If there are left over
-- files, assign them to the packages returned by the
-- utilsPackageNames lens, and make sure those packages are in the
-- source deb description.
makeUtilsPackage :: forall m. (Monad m) => PackageDescription -> CompilerFlavor -> CabalT m ()
makeUtilsPackage :: forall (m :: * -> *).
Monad m =>
PackageDescription -> CompilerFlavor -> CabalT m ()
makeUtilsPackage PackageDescription
pkgDesc CompilerFlavor
hc =
    do -- Files the cabal package expects to be installed
       -- Files that are already assigned to any binary deb
       Map BinPkgName (Set [Char])
installedDataMap <- forall a b. (a -> b -> b) -> b -> Set a -> b
Set.fold (\ Atom
x Map BinPkgName (Set [Char])
r ->
                                         case Atom
x of
                                           D.Install BinPkgName
b [Char]
src [Char]
_ -> forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b (forall a. a -> Set a
singleton [Char]
src) Map BinPkgName (Set [Char])
r
                                           D.InstallTo BinPkgName
b [Char]
src [Char]
_ -> forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b (forall a. a -> Set a
singleton [Char]
src) Map BinPkgName (Set [Char])
r
                                           D.InstallData BinPkgName
b [Char]
src  [Char]
_ -> forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b (forall a. a -> Set a
singleton [Char]
src) Map BinPkgName (Set [Char])
r
                                           Atom
_ -> Map BinPkgName (Set [Char])
r) forall a. Monoid a => a
mempty forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) :: CabalT m (Map BinPkgName (Set FilePath))
       Map BinPkgName (Set [Char])
installedExecMap <- forall a b. (a -> b -> b) -> b -> Set a -> b
Set.fold (\ Atom
x Map BinPkgName (Set [Char])
r ->
                                         case Atom
x of
                                           D.InstallCabalExec BinPkgName
b [Char]
name [Char]
_ -> forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b (forall a. a -> Set a
singleton [Char]
name) Map BinPkgName (Set [Char])
r
                                           D.InstallCabalExecTo BinPkgName
b [Char]
name [Char]
_ -> forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith forall a. Ord a => Set a -> Set a -> Set a
Set.union BinPkgName
b (forall a. a -> Set a
singleton [Char]
name) Map BinPkgName (Set [Char])
r
                                           Atom
_ -> Map BinPkgName (Set [Char])
r) forall a. Monoid a => a
mempty forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) :: CabalT m (Map BinPkgName (Set String))

       -- The names of cabal executables that go into eponymous debs
       Set [Char]
insExecPkg <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Map BinPkgName InstallFile)
D.executable) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map InstallFile -> [Char]
ename forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => [a] -> Set a
Set.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k a. Map k a -> [a]
elems

       let installedData :: Set (FilePath, FilePath)
           installedData :: Set ([Char], [Char])
installedData = forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\ [Char]
a -> ([Char]
a, [Char]
a)) forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions (forall k a. Map k a -> [a]
Map.elems Map BinPkgName (Set [Char])
installedDataMap)
           installedExec :: Set String
           installedExec :: Set [Char]
installedExec = forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions (forall k a. Map k a -> [a]
Map.elems Map BinPkgName (Set [Char])
installedExecMap)

       [Char]
prefixPath <- forall (m :: * -> *). Monad m => CabalT m [Char]
dataTop
       let dataFilePaths :: Set ([Char], [Char])
dataFilePaths = forall a. Ord a => [a] -> Set a
Set.fromList (forall a b. [a] -> [b] -> [(a, b)]
zip (forall a b. (a -> b) -> [a] -> [b]
List.map ([Char]
prefixPath [Char] -> [Char] -> [Char]
</>) (PackageDescription -> [[Char]]
Cabal.dataFiles PackageDescription
pkgDesc)) (PackageDescription -> [[Char]]
Cabal.dataFiles PackageDescription
pkgDesc)) :: Set (FilePath, FilePath)
           execFilePaths :: Set FilePath
           execFilePaths :: Set [Char]
execFilePaths = forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (UnqualComponentName -> [Char]
unUnqualComponentName forall b c a. (b -> c) -> (a -> b) -> a -> c
. Executable -> UnqualComponentName
Cabal.exeName) (forall a. (a -> Bool) -> Set a -> Set a
Set.filter (BuildInfo -> Bool
Cabal.buildable forall b c a. (b -> c) -> (a -> b) -> a -> c
. Executable -> BuildInfo
Cabal.buildInfo) (forall a. Ord a => [a] -> Set a
Set.fromList (PackageDescription -> [Executable]
Cabal.executables PackageDescription
pkgDesc))) :: Set FilePath
       let availableData :: Set ([Char], [Char])
availableData = forall a. Ord a => Set a -> Set a -> Set a
Set.union Set ([Char], [Char])
installedData Set ([Char], [Char])
dataFilePaths
           availableExec :: Set [Char]
availableExec = forall a. Ord a => Set a -> Set a -> Set a
Set.union Set [Char]
installedExec Set [Char]
execFilePaths

       forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe [Char])
D.utilsPackageNameBase) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ Maybe [Char]
name ->
           case Maybe [Char]
name of
             Maybe [Char]
Nothing -> forall (m :: * -> *) name.
(Monad m, PkgName name) =>
PackageType -> CompilerFlavor -> CabalT m name
debianName PackageType
B.Utilities CompilerFlavor
hc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ (BinPkgName [Char]
name') -> (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe [Char])
D.utilsPackageNameBase) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= forall a. a -> Maybe a
Just [Char]
name'
             Maybe [Char]
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
       BinPkgName
b <- forall (m :: * -> *) name.
(Monad m, PkgName name) =>
PackageType -> CompilerFlavor -> CabalT m name
debianName PackageType
B.Utilities CompilerFlavor
hc

       -- Files that are installed into packages other than the utils packages
       let installedDataOther :: Set ([Char], [Char])
installedDataOther = forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\ [Char]
a -> ([Char]
a, [Char]
a)) forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions forall a b. (a -> b) -> a -> b
$ forall k a. Map k a -> [a]
Map.elems forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> Map k a -> Map k a
Map.delete BinPkgName
b Map BinPkgName (Set [Char])
installedDataMap
           installedExecOther :: Set [Char]
installedExecOther = forall a. Ord a => Set a -> Set a -> Set a
Set.union Set [Char]
insExecPkg forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a. (Foldable f, Ord a) => f (Set a) -> Set a
Set.unions forall a b. (a -> b) -> a -> b
$ forall k a. Map k a -> [a]
Map.elems forall a b. (a -> b) -> a -> b
$ forall k a. Ord k => k -> Map k a -> Map k a
Map.delete BinPkgName
b Map BinPkgName (Set [Char])
installedExecMap

       -- Files that will be in utils packages
       let utilsData :: Set ([Char], [Char])
utilsData = forall a. Ord a => Set a -> Set a -> Set a
Set.difference Set ([Char], [Char])
availableData Set ([Char], [Char])
installedDataOther
           utilsExec :: Set [Char]
utilsExec = forall a. Ord a => Set a -> Set a -> Set a
Set.difference Set [Char]
availableExec Set [Char]
installedExecOther
       -- Files that still need to be assigned to the utils packages
       let utilsDataMissing :: Set ([Char], [Char])
utilsDataMissing = forall a. Ord a => Set a -> Set a -> Set a
Set.difference Set ([Char], [Char])
utilsData Set ([Char], [Char])
installedData
           utilsExecMissing :: Set [Char]
utilsExecMissing = forall a. Ord a => Set a -> Set a -> Set a
Set.difference Set [Char]
utilsExec Set [Char]
installedExec
       -- If any files belong in the utils packages, make sure they exist
       forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not (forall a. Set a -> Bool
Set.null Set ([Char], [Char])
utilsData Bool -> Bool -> Bool
&& forall a. Set a -> Bool
Set.null Set [Char]
utilsExec)) forall a b. (a -> b) -> a -> b
$ do
         (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe Text)
B.description) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just Text
desc
         -- This is really for all binary debs except the libraries - I'm not sure why
         (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Text)
D.rulesFragments) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a. Ord a => a -> Set a -> Set a
Set.insert ([Char] -> Text
pack ([Char]
"build" [Char] -> [Char] -> [Char]
</> forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b forall a. [a] -> [a] -> [a]
++ [Char]
":: build-ghc-stamp\n"))
         (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe PackageArchitectures)
B.architecture) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just (if forall a. Set a -> Bool
Set.null Set [Char]
utilsExec then PackageArchitectures
All else PackageArchitectures
Any)
         (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Lens' DebInfo BinaryDebDescription
D.binaryDebDescription BinPkgName
b forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' BinaryDebDescription (Maybe Section)
B.binarySection) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just ([Char] -> Section
MainSection [Char]
"misc")
         forall (m :: * -> *).
Monad m =>
BinPkgName -> PackageType -> CabalT m ()
binaryPackageRelations BinPkgName
b PackageType
B.Utilities
       -- Add the unassigned files to the utils packages
       forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\ ([Char]
foo, [Char]
bar) -> (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => a -> Set a -> Set a
Set.insert forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.InstallData BinPkgName
b [Char]
foo [Char]
bar)) Set ([Char], [Char])
utilsDataMissing
       forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (\ [Char]
name -> (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => a -> Set a -> Set a
Set.insert forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.InstallCabalExec BinPkgName
b [Char]
name [Char]
"usr/bin")) Set [Char]
utilsExecMissing
    where
      ename :: InstallFile -> [Char]
ename InstallFile
i =
          case InstallFile -> Maybe [Char]
D.sourceDir InstallFile
i of
            Maybe [Char]
Nothing -> InstallFile -> [Char]
D.execName InstallFile
i
            Just [Char]
s ->  [Char]
s [Char] -> [Char] -> [Char]
</> InstallFile -> [Char]
D.execName InstallFile
i

expandAtoms :: Monad m => CabalT m () -> CabalT m ()
expandAtoms :: forall (m :: * -> *). Monad m => CabalT m () -> CabalT m ()
expandAtoms CabalT m ()
goodies =
    do CompilerFlavor
hc <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Flags
D.flags forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Flags CompilerFlavor
compilerFlavor)
       case CompilerFlavor
hc of
         CompilerFlavor
GHC -> (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Flags
D.flags forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Flags (Set (FlagName, Bool))
cabalFlagAssignments) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => Set a -> Set a -> Set a
Set.union (forall a. Ord a => [a] -> Set a
Set.fromList ([Char] -> [(FlagName, Bool)]
flagList [Char]
"--ghc")))
         CompilerFlavor
GHCJS -> (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Flags
D.flags forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Flags (Set (FlagName, Bool))
cabalFlagAssignments) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => Set a -> Set a -> Set a
Set.union (forall a. Ord a => [a] -> Set a
Set.fromList ([Char] -> [(FlagName, Bool)]
flagList [Char]
"--ghcjs")))
         CompilerFlavor
x -> forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"Sorry, compiler not supported: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show CompilerFlavor
x
       [Char]
builddir <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe [Char])
D.buildDir) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe (case CompilerFlavor
hc of
                                                               CompilerFlavor
GHC -> [Char]
"dist-ghc/build"
                                                               CompilerFlavor
GHCJS -> [Char]
"dist-ghcjs/build"
                                                               CompilerFlavor
_ -> forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"Unexpected compiler: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show CompilerFlavor
hc)
       [Char]
dDest <- forall (m :: * -> *). Monad m => CabalT m [Char]
dataDest
       forall (m :: * -> *). Monad m => CabalT m ()
expandApacheSites
       forall (m :: * -> *). Monad m => [Char] -> CabalT m ()
expandInstallCabalExecs [Char]
builddir
       forall (m :: * -> *). Monad m => [Char] -> CabalT m ()
expandInstallCabalExecTo [Char]
builddir
       forall (m :: * -> *). Monad m => [Char] -> CabalT m ()
expandInstallData [Char]
dDest
       forall (m :: * -> *). Monad m => CabalT m ()
expandInstallTo
       forall (m :: * -> *). Monad m => CabalT m ()
expandFile
#if 1
       CabalT m ()
goodies
#else
       expandWebsite
       expandServer
       expandBackups
#endif
       forall (m :: * -> *). Monad m => CabalT m ()
expandExecutable
    where
      expandApacheSites :: Monad m => CabalT m ()
      expandApacheSites :: forall (m :: * -> *). Monad m => CabalT m ()
expandApacheSites =
          do Map BinPkgName ([Char], [Char], Text)
mp <- forall s (m :: * -> *). MonadState s m => m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Map BinPkgName ([Char], [Char], Text))
D.apacheSite)
             forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ forall {m :: * -> *}.
MonadState CabalInfo m =>
(BinPkgName, ([Char], [Char], Text)) -> m ()
expandApacheSite (forall k a. Map k a -> [(k, a)]
Map.toList Map BinPkgName ([Char], [Char], Text)
mp)
          where
            expandApacheSite :: (BinPkgName, ([Char], [Char], Text)) -> m ()
expandApacheSite (BinPkgName
b, ([Char]
dom, [Char]
log, Text
text)) =
                do (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => a -> Set a -> Set a
Set.insert forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.Link BinPkgName
b ([Char]
"/etc/apache2/sites-available/" forall a. [a] -> [a] -> [a]
++ [Char]
dom) ([Char]
"/etc/apache2/sites-enabled/" forall a. [a] -> [a] -> [a]
++ [Char]
dom))
                   (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => a -> Set a -> Set a
Set.insert forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> Atom
D.InstallDir BinPkgName
b [Char]
log)
                   (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => a -> Set a -> Set a
Set.insert forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> Text -> Atom
D.File BinPkgName
b ([Char]
"/etc/apache2/sites-available" [Char] -> [Char] -> [Char]
</> [Char]
dom) Text
text)

      -- Turn A.InstallCabalExec into A.Install
      expandInstallCabalExecs :: Monad m => FilePath -> CabalT m ()
      expandInstallCabalExecs :: forall (m :: * -> *). Monad m => [Char] -> CabalT m ()
expandInstallCabalExecs [Char]
builddir = do
        CompilerFlavor
hc <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Flags
D.flags forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Flags CompilerFlavor
compilerFlavor)
        forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (forall (m :: * -> *).
Monad m =>
CompilerFlavor -> Atom -> CabalT m ()
doAtom CompilerFlavor
hc)
          where
            doAtom :: Monad m => CompilerFlavor -> D.Atom -> CabalT m ()
            doAtom :: forall (m :: * -> *).
Monad m =>
CompilerFlavor -> Atom -> CabalT m ()
doAtom CompilerFlavor
GHC (D.InstallCabalExec BinPkgName
b [Char]
name [Char]
dest) = (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => a -> Set a -> Set a
Set.insert forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.Install BinPkgName
b ([Char]
builddir [Char] -> [Char] -> [Char]
</> [Char]
name [Char] -> [Char] -> [Char]
</> [Char]
name) [Char]
dest)
            -- A GHCJS executable is a directory with files, copy them
            -- all into place.
            doAtom CompilerFlavor
GHCJS (D.InstallCabalExec BinPkgName
b [Char]
name [Char]
dest) =
                (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Text)
D.rulesFragments) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a. Ord a => a -> Set a -> Set a
Set.insert
                     ([Text] -> Text
Text.unlines
                        [ [Char] -> Text
pack ([Char]
"binary-fixup" [Char] -> [Char] -> [Char]
</> forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b) forall a. Semigroup a => a -> a -> a
<> Text
"::"
                        , [Char] -> Text
pack ([Char]
"\t(cd " forall a. Semigroup a => a -> a -> a
<> [Char]
builddir [Char] -> [Char] -> [Char]
</> [Char]
name forall a. Semigroup a => a -> a -> a
<> [Char]
" && find -L " forall a. Semigroup a => a -> a -> a
<> [Char]
name [Char] -> [Char] -> [Char]
<.> [Char]
"jsexe" forall a. Semigroup a => a -> a -> a
<> [Char]
" -type f) |\\\n" forall a. Semigroup a => a -> a -> a
<>
                                       [Char]
"\t  while read i; do install -Dp " forall a. Semigroup a => a -> a -> a
<> [Char]
builddir [Char] -> [Char] -> [Char]
</> [Char]
name [Char] -> [Char] -> [Char]
</> [Char]
"$$i debian" [Char] -> [Char] -> [Char]
</> forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b [Char] -> [Char] -> [Char]
</> [Char] -> [Char] -> [Char]
makeRelative [Char]
"/" [Char]
dest [Char] -> [Char] -> [Char]
</> [Char]
"$$i; done\n") ])
            doAtom CompilerFlavor
_ Atom
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ()

      -- Turn A.InstallCabalExecTo into a make rule
      expandInstallCabalExecTo :: Monad m => FilePath -> CabalT m ()
      expandInstallCabalExecTo :: forall (m :: * -> *). Monad m => [Char] -> CabalT m ()
expandInstallCabalExecTo [Char]
builddir = do
        CompilerFlavor
hc <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Flags
D.flags forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Flags CompilerFlavor
compilerFlavor)
        forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (forall (m :: * -> *).
Monad m =>
CompilerFlavor -> Atom -> CabalT m ()
doAtom CompilerFlavor
hc)
          where
            doAtom :: Monad m => CompilerFlavor -> D.Atom -> CabalT m ()
            doAtom :: forall (m :: * -> *).
Monad m =>
CompilerFlavor -> Atom -> CabalT m ()
doAtom CompilerFlavor
GHC (D.InstallCabalExecTo BinPkgName
b [Char]
name [Char]
dest) =
                (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Text)
D.rulesFragments) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a. Ord a => a -> Set a -> Set a
Set.insert
                                     ([Text] -> Text
Text.unlines
                                       [ [Char] -> Text
pack ([Char]
"binary-fixup" [Char] -> [Char] -> [Char]
</> forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b) forall a. Semigroup a => a -> a -> a
<> Text
"::"
                                       , Text
"\tinstall -Dps " forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack ([Char]
builddir [Char] -> [Char] -> [Char]
</> [Char]
name [Char] -> [Char] -> [Char]
</> [Char]
name) forall a. Semigroup a => a -> a -> a
<> Text
" "
                                                           forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack ([Char]
"debian" [Char] -> [Char] -> [Char]
</> forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b [Char] -> [Char] -> [Char]
</> [Char] -> [Char] -> [Char]
makeRelative [Char]
"/" [Char]
dest) ])
            doAtom CompilerFlavor
hc (D.InstallCabalExecTo BinPkgName
b [Char]
name [Char]
dest) = forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"expandInstallCabalExecTo " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show CompilerFlavor
hc forall a. [a] -> [a] -> [a]
++ [Char]
" " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show (BinPkgName -> [Char] -> [Char] -> Atom
D.InstallCabalExecTo BinPkgName
b [Char]
name [Char]
dest)
            doAtom CompilerFlavor
_ Atom
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ()

      -- Turn A.InstallData into either an Install or an InstallTo
      expandInstallData :: Monad m => FilePath -> CabalT m ()
      expandInstallData :: forall (m :: * -> *). Monad m => [Char] -> CabalT m ()
expandInstallData [Char]
dDest =
          forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Set a -> [a]
Set.toList
          where
            doAtom :: Monad m => D.Atom -> CabalT m ()
            doAtom :: forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom (D.InstallData BinPkgName
b [Char]
src [Char]
dest) =
                if [Char] -> [Char]
takeFileName [Char]
src forall a. Eq a => a -> a -> Bool
== [Char] -> [Char]
takeFileName [Char]
dest
                then (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => a -> Set a -> Set a
Set.insert forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.Install BinPkgName
b [Char]
src ([Char]
dDest [Char] -> [Char] -> [Char]
</> [Char] -> [Char] -> [Char]
makeRelative [Char]
"/" ([Char] -> [Char]
takeDirectory [Char]
dest)))
                else (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => a -> Set a -> Set a
Set.insert forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.InstallTo BinPkgName
b [Char]
src ([Char]
dDest [Char] -> [Char] -> [Char]
</> [Char] -> [Char] -> [Char]
makeRelative [Char]
"/" [Char]
dest))
            doAtom Atom
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ()

      -- Turn A.InstallTo into a make rule
      expandInstallTo :: Monad m => CabalT m ()
      expandInstallTo :: forall (m :: * -> *). Monad m => CabalT m ()
expandInstallTo =
          forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Set a -> [a]
Set.toList
          where
            doAtom :: Monad m => D.Atom -> CabalT m ()
            doAtom :: forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom (D.InstallTo BinPkgName
b [Char]
src [Char]
dest) =
                (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Text)
D.rulesFragments) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a. Ord a => a -> Set a -> Set a
Set.insert
                                    ([Text] -> Text
Text.unlines [ [Char] -> Text
pack ([Char]
"binary-fixup" [Char] -> [Char] -> [Char]
</> forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b) forall a. Semigroup a => a -> a -> a
<> Text
"::"
                                                  , Text
"\tinstall -Dp " forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
src forall a. Semigroup a => a -> a -> a
<> Text
" " forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack ([Char]
"debian" [Char] -> [Char] -> [Char]
</> forall a. Pretty (PP a) => a -> [Char]
ppShow BinPkgName
b [Char] -> [Char] -> [Char]
</> [Char] -> [Char] -> [Char]
makeRelative [Char]
"/" [Char]
dest) ])
            doAtom Atom
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ()

      -- Turn A.File into an intermediateFile and an A.Install
      expandFile :: Monad m => CabalT m ()
      expandFile :: forall (m :: * -> *). Monad m => CabalT m ()
expandFile =
          forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Set a -> [a]
Set.toList
          where
            doAtom :: Monad m => D.Atom -> CabalT m ()
            doAtom :: forall (m :: * -> *). Monad m => Atom -> CabalT m ()
doAtom (D.File BinPkgName
b [Char]
path Text
text) =
                do let ([Char]
destDir', [Char]
destName') = [Char] -> ([Char], [Char])
splitFileName [Char]
path
                       tmpDir :: [Char]
tmpDir = [Char]
"debian/cabalInstall" [Char] -> [Char] -> [Char]
</> forall a. Show a => a -> [Char]
show (ByteString -> MD5Digest
md5 ([Char] -> ByteString
fromString (Text -> [Char]
unpack Text
text)))
                       tmpPath :: [Char]
tmpPath = [Char]
tmpDir [Char] -> [Char] -> [Char]
</> [Char]
destName'
                   (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set ([Char], Text))
D.intermediateFiles) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= forall a. Ord a => a -> Set a -> Set a
Set.insert ([Char]
tmpPath, Text
text)
                   (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Set Atom)
D.atomSet) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => a -> Set a -> Set a
Set.insert forall a b. (a -> b) -> a -> b
$ BinPkgName -> [Char] -> [Char] -> Atom
D.Install BinPkgName
b [Char]
tmpPath [Char]
destDir')
            doAtom Atom
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ()

      expandExecutable :: Monad m => CabalT m ()
      expandExecutable :: forall (m :: * -> *). Monad m => CabalT m ()
expandExecutable =
          do Map BinPkgName InstallFile
mp <- forall s (m :: * -> *). MonadState s m => m s
get forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Map BinPkgName InstallFile)
D.executable)
             forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
List.mapM_ (\ (BinPkgName
b, InstallFile
f) -> forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (BinPkgName -> InstallFile -> CabalInfo -> CabalInfo
execAtoms BinPkgName
b InstallFile
f)) (forall k a. Map k a -> [(k, a)]
Map.toList Map BinPkgName InstallFile
mp)

-- | Add the normal default values to the rules files.
finalizeRules :: (MonadIO m) => CabalT m ()
finalizeRules :: forall (m :: * -> *). MonadIO m => CabalT m ()
finalizeRules =
    do DebBase [Char]
b <- forall (m :: * -> *). Monad m => CabalT m DebBase
debianNameBase
       CompilerFlavor
hc <- forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Flags
D.flags forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Flags CompilerFlavor
compilerFlavor)
       Maybe BinPkgName
cpn <- forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ CompilerFlavor -> PackageType -> IO (Maybe BinPkgName)
compilerPackageName CompilerFlavor
hc PackageType
B.Development
       let BinPkgName [Char]
hcdeb = forall a. a -> Maybe a -> a
fromMaybe (forall a. HasCallStack => [Char] -> a
error [Char]
"No compiler package") Maybe BinPkgName
cpn
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo (Maybe Text)
D.rulesHead) forall (m :: * -> *) a b.
Monad m =>
Lens' a (Maybe b) -> Maybe b -> StateT a m ()
.?= forall a. a -> Maybe a
Just Text
"#!/usr/bin/make -f"
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo [Text]
D.rulesSettings) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. [a] -> [a] -> [a]
++ [Text
"DEB_CABAL_PACKAGE = " forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
b])
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo [Text]
D.rulesSettings) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. [a] -> [a] -> [a]
++ [Text
"DEB_DEFAULT_COMPILER = " forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
hcdeb])
       [Char]
flags <- [(FlagName, Bool)] -> [Char]
flagString forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Set a -> [a]
Set.toList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo Flags
D.flags forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' Flags (Set (FlagName, Bool))
cabalFlagAssignments)
       forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
List.null [Char]
flags) ((Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo [Text]
D.rulesSettings) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. [a] -> [a] -> [a]
++ [Text
"DEB_SETUP_GHC_CONFIGURE_ARGS = " forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
flags]))
       (Lens' CabalInfo DebInfo
A.debInfo forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens' DebInfo [Text]
D.rulesIncludes) forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (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
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_ -> [Char] -> [Char]
[Dependency_] -> [Char] -> [Char]
Dependency_ -> [Char]
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
showList :: [Dependency_] -> [Char] -> [Char]
$cshowList :: [Dependency_] -> [Char] -> [Char]
show :: Dependency_ -> [Char]
$cshow :: Dependency_ -> [Char]
showsPrec :: Int -> Dependency_ -> [Char] -> [Char]
$cshowsPrec :: Int -> Dependency_ -> [Char] -> [Char]
Show)

anyrel :: String -> [D.Relation]
anyrel :: [Char] -> [Relation]
anyrel [Char]
x = BinPkgName -> [Relation]
anyrel' ([Char] -> BinPkgName
D.BinPkgName [Char]
x)

anyrel' :: D.BinPkgName -> [D.Relation]
anyrel' :: BinPkgName -> [Relation]
anyrel' BinPkgName
x = [BinPkgName -> Maybe VersionReq -> Maybe ArchitectureReq -> Relation
D.Rel BinPkgName
x forall a. Maybe a
Nothing forall a. Maybe a
Nothing]

-- Lifted from Distribution.Simple.Setup, since it's not exported.
flagList :: String -> [(FlagName, Bool)]
flagList :: [Char] -> [(FlagName, Bool)]
flagList = forall a b. (a -> b) -> [a] -> [b]
List.map [Char] -> (FlagName, Bool)
tagWithValue forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
words
  where tagWithValue :: [Char] -> (FlagName, Bool)
tagWithValue (Char
'-':[Char]
name) = ([Char] -> FlagName
mkFlagName (forall a b. (a -> b) -> [a] -> [b]
List.map Char -> Char
toLower [Char]
name), Bool
False)
        tagWithValue [Char]
name       = ([Char] -> FlagName
mkFlagName (forall a b. (a -> b) -> [a] -> [b]
List.map Char -> Char
toLower [Char]
name), Bool
True)

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