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