-- | Convert a Debianization into a list of files that can then be
-- written out.
{-# LANGUAGE FlexibleContexts, FlexibleInstances, OverloadedStrings, ScopedTypeVariables, TupleSections #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Debian.Debianize.Files
    ( debianizationFileMap
    ) where


import Control.Lens
import Control.Monad.Trans (lift)
import Control.Monad.Writer (execWriterT, tell, WriterT)
import Data.Char (isSpace)
import Data.List as List (dropWhile, dropWhileEnd, map)
import Data.Map as Map (fromListWithKey, insertWith, map, Map, mapKeys, toList)
import Data.Maybe (fromMaybe)
import Data.Set as Set (fold, member, toList)
import Data.Text as Text (dropWhile, dropWhileEnd, intercalate, lines, null, pack, strip, Text, unlines, unpack)
import Debian.Control (Control'(Control, unControl), Field'(Field), Paragraph'(Paragraph))
import Debian.Control.Common ()
import qualified Debian.Debianize.DebInfo as D (Atom(Install, InstallDir, Link), atomSet, changelog, compat, control, copyright, installInit, intermediateFiles, logrotateStanza, postInst, postRm, preInst, preRm, rulesFragments, rulesHead, rulesIncludes, rulesSettings, sourceFormat, watch)
import Debian.Debianize.Monad (DebianT)
import Debian.Debianize.Prelude (escapeDebianWildcards, showDeps')
import qualified Debian.Debianize.BinaryDebDescription as B (architecture, BinaryDebDescription, binaryPriority, multiArch, binarySection, breaks, builtUsing, conflicts, depends, description, essential, package, PackageRelations, preDepends, provides, recommends, relations, replaces, suggests)
import Debian.Debianize.CopyrightDescription (CopyrightDescription)
import qualified Debian.Debianize.SourceDebDescription as S (binaryPackages, buildConflicts, buildConflictsIndep, buildDepends, buildDependsIndep, dmUploadAllowed, homepage, maintainer, priority, rulesRequiresRoot, section, source, SourceDebDescription, standardsVersion, uploaders, vcsFields, VersionControlSpec(VCSArch, VCSBrowser, VCSBzr, VCSCvs, VCSDarcs, VCSGit, VCSHg, VCSMtn, VCSSvn), xDescription, XField(XField), XFieldDest(B, C, S), xFields)
import Debian.Policy (maintainerOfLastResort)
import Debian.Pretty (PP(..), ppShow, prettyText, ppText, ppPrint)
import Debian.Relation (BinPkgName(BinPkgName), Relations)
import Distribution.PackageDescription (PackageDescription)
import Prelude hiding (dropWhile, init, log, unlines, writeFile)
import System.FilePath ((</>))
import Text.PrettyPrint.HughesPJClass (empty, text)
import Distribution.Pretty (Pretty(pretty))

type FilesT m = WriterT [(FilePath, Text)] (DebianT m)

instance Pretty (PP Bool) where
    pretty :: PP Bool -> Doc
pretty = [Char] -> Doc
text forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> [Char]
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. PP a -> a
unPP

-- | Turn the Debianization into a list of files, making sure the text
-- associated with each path is unique.  Assumes that
-- finalizeDebianization has already been called.  (Yes, I'm
-- considering building one into the other, but it is handy to look at
-- the Debianization produced by finalizeDebianization in the unit
-- tests.)

debianizationFileMap :: (MonadFail m) => DebianT m (Map FilePath Text)
debianizationFileMap :: forall (m :: * -> *). MonadFail m => DebianT m (Map [Char] Text)
debianizationFileMap =
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall k a. Ord k => (k -> a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWithKey (\ [Char]
k Text
a Text
b -> forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"Multiple values for " forall a. [a] -> [a] -> [a]
++ [Char]
k forall a. [a] -> [a] -> [a]
++ [Char]
":\n  " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Text
a forall a. [a] -> [a] -> [a]
++ [Char]
"\n" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Text
b)) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) w a. Monad m => WriterT w m a -> m w
execWriterT forall a b. (a -> b) -> a -> b
$
    do -- here <- liftIO getCurrentDirectory
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
control
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
changelog
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). MonadFail m => FilesT m [([Char], Text)]
rules
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
compat
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
copyright
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
sourceFormatFiles
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
watchFile
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
installs
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
dirs
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
init
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
logrotate
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
links
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
postinstFiles
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
postrmFiles
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
preinstFiles
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
prermFiles
       forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
intermediates

sourceFormatFiles :: (Monad m) => FilesT m [(FilePath, Text)]
sourceFormatFiles :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
sourceFormatFiles = do
    SourceFormat
fmt <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo SourceFormat
D.sourceFormat
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [([Char]
"debian/source/format", [Char] -> Text
pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Pretty (PP a) => a -> [Char]
ppShow forall a b. (a -> b) -> a -> b
$ SourceFormat
fmt)]

watchFile :: (Monad m) => FilesT m [(FilePath, Text)]
watchFile :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
watchFile = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\ Text
x -> [([Char]
"debian/watch", Text
x)]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Maybe Text)
D.watch)

intermediates :: (Monad m) => FilesT m [(FilePath, Text)]
intermediates :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
intermediates = forall a. Set a -> [a]
Set.toList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Set ([Char], Text))
D.intermediateFiles)

installs :: (Monad m) => FilesT m [(FilePath, Text)]
installs :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
installs =
    (forall k a. Map k a -> [(k, a)]
Map.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b k. (a -> b) -> Map k a -> Map k b
Map.map [Text] -> Text
unlines forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b -> b) -> b -> Set a -> b
Set.fold Atom -> Map [Char] [Text] -> Map [Char] [Text]
doAtom forall a. Monoid a => a
mempty) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' DebInfo (Set Atom)
D.atomSet))
    where
      doAtom :: Atom -> Map [Char] [Text] -> Map [Char] [Text]
doAtom (D.Install BinPkgName
b [Char]
frm [Char]
dst) Map [Char] [Text]
mp = forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith forall a. [a] -> [a] -> [a]
(++) (forall a. Pretty (PP a) => a -> [Char]
pathf BinPkgName
b) [[Char] -> Text
pack ([Char] -> [Char]
escapeDebianWildcards [Char]
frm forall a. Semigroup a => a -> a -> a
<> [Char]
" " forall a. Semigroup a => a -> a -> a
<> [Char]
dst)] Map [Char] [Text]
mp
      doAtom Atom
_ Map [Char] [Text]
mp = Map [Char] [Text]
mp
      pathf :: a -> [Char]
pathf a
name = [Char]
"debian" [Char] -> [Char] -> [Char]
</> forall a. Show a => a -> [Char]
show (forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) forall a. [a] -> [a] -> [a]
++ [Char]
".install"

dirs :: (Monad m) => FilesT m [(FilePath, Text)]
dirs :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
dirs =
    (forall k a. Map k a -> [(k, a)]
Map.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b k. (a -> b) -> Map k a -> Map k b
Map.map [Text] -> Text
unlines forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b -> b) -> b -> Set a -> b
Set.fold Atom -> Map [Char] [Text] -> Map [Char] [Text]
doAtom forall a. Monoid a => a
mempty) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Set Atom)
D.atomSet)
    where
      doAtom :: Atom -> Map [Char] [Text] -> Map [Char] [Text]
doAtom (D.InstallDir BinPkgName
b [Char]
dir) Map [Char] [Text]
mp = forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith forall a. [a] -> [a] -> [a]
(++) (forall a. Pretty (PP a) => a -> [Char]
pathf BinPkgName
b) [[Char] -> Text
pack [Char]
dir] Map [Char] [Text]
mp
      doAtom Atom
_ Map [Char] [Text]
mp = Map [Char] [Text]
mp
      pathf :: a -> [Char]
pathf a
name = [Char]
"debian" [Char] -> [Char] -> [Char]
</> forall a. Show a => a -> [Char]
show (forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) forall a. [a] -> [a] -> [a]
++ [Char]
".dirs"

init :: (Monad m) => FilesT m [(FilePath, Text)]
init :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
init =
    (forall k a. Map k a -> [(k, a)]
Map.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
mapKeys forall a. Pretty (PP a) => a -> [Char]
pathf) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Map BinPkgName Text)
D.installInit)
    where
      pathf :: a -> [Char]
pathf a
name = [Char]
"debian" [Char] -> [Char] -> [Char]
</> forall a. Show a => a -> [Char]
show (forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) forall a. [a] -> [a] -> [a]
++ [Char]
".init"

-- FIXME - use a map and insertWith, check for multiple entries
logrotate :: (Monad m) => FilesT m [(FilePath, Text)]
logrotate :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
logrotate =
    (forall k a. Map k a -> [(k, a)]
Map.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (\ Set Text
stanzas -> [Text] -> Text
Text.unlines (forall a. Set a -> [a]
Set.toList Set Text
stanzas)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
mapKeys forall a. Pretty (PP a) => a -> [Char]
pathf) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Map BinPkgName (Set Text))
D.logrotateStanza)
    where
      pathf :: a -> [Char]
pathf a
name = [Char]
"debian" [Char] -> [Char] -> [Char]
</> forall a. Show a => a -> [Char]
show (forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) forall a. [a] -> [a] -> [a]
++ [Char]
".logrotate"

-- | Assemble all the links by package and output one file each
links :: (Monad m) => FilesT m [(FilePath, Text)]
links :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
links =
    (forall k a. Map k a -> [(k, a)]
Map.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b k. (a -> b) -> Map k a -> Map k b
Map.map [Text] -> Text
unlines forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b -> b) -> b -> Set a -> b
Set.fold Atom -> Map [Char] [Text] -> Map [Char] [Text]
doAtom forall a. Monoid a => a
mempty) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Set Atom)
D.atomSet)
    where
      doAtom :: Atom -> Map [Char] [Text] -> Map [Char] [Text]
doAtom (D.Link BinPkgName
b [Char]
loc [Char]
t) Map [Char] [Text]
mp = forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith forall a. [a] -> [a] -> [a]
(++) (forall a. Pretty (PP a) => a -> [Char]
pathf BinPkgName
b) [[Char] -> Text
pack [Char]
loc forall a. Semigroup a => a -> a -> a
<> Text
" " forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
t] Map [Char] [Text]
mp
      doAtom Atom
_ Map [Char] [Text]
mp = Map [Char] [Text]
mp
      pathf :: a -> [Char]
pathf a
name = [Char]
"debian" [Char] -> [Char] -> [Char]
</> forall a. Show a => a -> [Char]
show (forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) forall a. [a] -> [a] -> [a]
++ [Char]
".links"

postinstFiles :: (Monad m) => FilesT m [(FilePath, Text)]
postinstFiles :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
postinstFiles =
     (forall k a. Map k a -> [(k, a)]
Map.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
mapKeys BinPkgName -> [Char]
pathf) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Map BinPkgName Text)
D.postInst)
    where
      pathf :: BinPkgName -> [Char]
pathf (BinPkgName [Char]
name) = [Char]
"debian" [Char] -> [Char] -> [Char]
</> [Char]
name forall a. Semigroup a => a -> a -> a
<> [Char]
".postinst"

postrmFiles :: (Monad m) => FilesT m [(FilePath, Text)]
postrmFiles :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
postrmFiles =
    (forall k a. Map k a -> [(k, a)]
Map.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
mapKeys forall a. Pretty (PP a) => a -> [Char]
pathf) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Map BinPkgName Text)
D.postRm)
    where
      pathf :: a -> [Char]
pathf a
name = [Char]
"debian" [Char] -> [Char] -> [Char]
</> forall a. Show a => a -> [Char]
show (forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) forall a. [a] -> [a] -> [a]
++ [Char]
".postrm"

preinstFiles :: (Monad m) => FilesT m [(FilePath, Text)]
preinstFiles :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
preinstFiles =
    (forall k a. Map k a -> [(k, a)]
Map.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
mapKeys forall a. Pretty (PP a) => a -> [Char]
pathf) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Map BinPkgName Text)
D.preInst)
    where
      pathf :: a -> [Char]
pathf a
name = [Char]
"debian" [Char] -> [Char] -> [Char]
</> forall a. Show a => a -> [Char]
show (forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) forall a. [a] -> [a] -> [a]
++ [Char]
".preinst"

prermFiles :: (Monad m) => FilesT m [(FilePath, Text)]
prermFiles :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
prermFiles =
    (forall k a. Map k a -> [(k, a)]
Map.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
mapKeys forall a. Pretty (PP a) => a -> [Char]
pathf) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Map BinPkgName Text)
D.preRm)
    where
      pathf :: a -> [Char]
pathf a
name = [Char]
"debian" [Char] -> [Char] -> [Char]
</> forall a. Show a => a -> [Char]
show (forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) forall a. [a] -> [a] -> [a]
++ [Char]
".prerm"

rules :: (MonadFail m) => FilesT m [(FilePath, Text)]
rules :: forall (m :: * -> *). MonadFail m => FilesT m [([Char], Text)]
rules =
    do Just Text
rh <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' DebInfo (Maybe Text)
D.rulesHead))
       Text
rassignments <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' DebInfo [Text]
D.rulesSettings)) 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
. Text -> [Text] -> Text
intercalate Text
"\n"
       Text
rincludes <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' DebInfo [Text]
D.rulesIncludes)) 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
. Text -> [Text] -> Text
intercalate Text
"\n"
       [Text]
rl <- (forall a. [a] -> [a]
reverse 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 (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' DebInfo (Set Text)
D.rulesFragments))
       forall (m :: * -> *) a. Monad m => a -> m a
return [([Char]
"debian/rules", Text -> [Text] -> Text
intercalate Text
"\n\n" (forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Bool
Text.null) (forall a b. (a -> b) -> [a] -> [b]
List.map Text -> Text
strip (Text
rh forall a. a -> [a] -> [a]
: Text
rassignments forall a. a -> [a] -> [a]
: Text
rincludes forall a. a -> [a] -> [a]
: [Text]
rl))) forall a. Semigroup a => a -> a -> a
<> Text
"\n")]

changelog :: (Monad m) => FilesT m [(FilePath, Text)]
changelog :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
changelog =
    do Maybe ChangeLog
log <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Maybe ChangeLog)
D.changelog
       forall (m :: * -> *) a. Monad m => a -> m a
return [([Char]
"debian/changelog", [Char] -> Text
pack (forall a. Show a => a -> [Char]
show (forall a. Pretty (PP a) => a -> Doc
ppPrint (forall a. a -> Maybe a -> a
fromMaybe (forall a. HasCallStack => [Char] -> a
error [Char]
"No changelog in debianization") Maybe ChangeLog
log))))]

control :: (Monad m) => FilesT m [(FilePath, Text)]
control :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
control =
    do SourceDebDescription
d <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo SourceDebDescription
D.control
       forall (m :: * -> *) a. Monad m => a -> m a
return [([Char]
"debian/control", forall a. Pretty a => a -> Text
prettyText (SourceDebDescription -> Control' [Char]
controlFile SourceDebDescription
d))]

compat :: (Monad m) => FilesT m [(FilePath, Text)]
compat :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
compat =
    do Maybe Int
t <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Lens' DebInfo (Maybe Int)
D.compat
       forall (m :: * -> *) a. Monad m => a -> m a
return [([Char]
"debian/compat", [Char] -> Text
pack (forall a. Show a => a -> [Char]
show (forall a. a -> Maybe a -> a
fromMaybe (forall a. HasCallStack => [Char] -> a
error [Char]
"Missing DebCompat atom - is debhelper installed?") forall a b. (a -> b) -> a -> b
$ Maybe Int
t) forall a. Semigroup a => a -> a -> a
<> [Char]
"\n"))]

copyright :: (Monad m) => FilesT m [(FilePath, Text)]
copyright :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
copyright =
    do Maybe CopyrightDescription
copyrt <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Lens' DebInfo (Maybe CopyrightDescription)
D.copyright)
       forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\ CopyrightDescription
x -> [([Char]
"debian/copyright", forall a. Pretty a => a -> Text
prettyText CopyrightDescription
x)]) Maybe CopyrightDescription
copyrt

instance Pretty (PP (PackageDescription -> IO CopyrightDescription)) where
    pretty :: PP (PackageDescription -> IO CopyrightDescription) -> Doc
pretty PP (PackageDescription -> IO CopyrightDescription)
_ = [Char] -> Doc
text [Char]
"<function>"

controlFile :: S.SourceDebDescription -> Control' String
controlFile :: SourceDebDescription -> Control' [Char]
controlFile SourceDebDescription
src =
    Control
    { unControl :: [Paragraph' [Char]]
unControl =
          (forall a. [Field' a] -> Paragraph' a
Paragraph
           ([forall a. (a, a) -> Field' a
Field ([Char]
"Source", [Char]
" " forall a. [a] -> [a] -> [a]
++ (forall a. Show a => a -> [Char]
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc
empty forall a. Pretty (PP a) => a -> Doc
ppPrint 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' SourceDebDescription (Maybe SrcPkgName)
S.source forall a b. (a -> b) -> a -> b
$ SourceDebDescription
src)),
             forall a. (a, a) -> Field' a
Field ([Char]
"Maintainer", [Char]
" " forall a. Semigroup a => a -> a -> a
<> (forall a. Pretty (PP a) => a -> [Char]
ppShow forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const NameAddr
maintainerOfLastResort) forall a. a -> a
id 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' SourceDebDescription (Either [Char] NameAddr)
S.maintainer forall a b. (a -> b) -> a -> b
$ SourceDebDescription
src))] forall a. [a] -> [a] -> [a]
++
            forall {a}. Pretty (PP [a]) => [Char] -> [a] -> [Field' [Char]]
lField [Char]
"Uploaders" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription [NameAddr]
S.uploaders SourceDebDescription
src) forall a. [a] -> [a] -> [a]
++
            (case forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription Bool
S.dmUploadAllowed SourceDebDescription
src of Bool
True -> [forall a. (a, a) -> Field' a
Field ([Char]
"DM-Upload-Allowed", [Char]
" yes")]; Bool
False -> []) forall a. [a] -> [a] -> [a]
++
            forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Priority" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription (Maybe PackagePriority)
S.priority SourceDebDescription
src) forall a. [a] -> [a] -> [a]
++
            forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Section" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription (Maybe Section)
S.section SourceDebDescription
src) forall a. [a] -> [a] -> [a]
++
            [forall a. (a, a) -> Field' a
Field ([Char]
"Rules-Requires-Root", (if forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription Bool
S.rulesRequiresRoot SourceDebDescription
src then [Char]
" yes" else [Char]
" no"))] forall a. [a] -> [a] -> [a]
++
            [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Build-Depends" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription Relations
S.buildDepends SourceDebDescription
src) forall a. [a] -> [a] -> [a]
++
            [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Build-Depends-Indep" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription Relations
S.buildDependsIndep SourceDebDescription
src) forall a. [a] -> [a] -> [a]
++
            [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Build-Conflicts" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription Relations
S.buildConflicts SourceDebDescription
src) forall a. [a] -> [a] -> [a]
++
            [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Build-Conflicts-Indep" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription Relations
S.buildConflictsIndep SourceDebDescription
src) forall a. [a] -> [a] -> [a]
++
            forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Standards-Version" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription (Maybe StandardsVersion)
S.standardsVersion SourceDebDescription
src) forall a. [a] -> [a] -> [a]
++
            forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Homepage" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription (Maybe Text)
S.homepage SourceDebDescription
src) forall a. [a] -> [a] -> [a]
++
            forall a b. (a -> b) -> [a] -> [b]
List.map VersionControlSpec -> Field' [Char]
vcsField (forall a. Set a -> [a]
Set.toList (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription (Set VersionControlSpec)
S.vcsFields SourceDebDescription
src)) forall a. [a] -> [a] -> [a]
++
            forall a b. (a -> b) -> [a] -> [b]
List.map XField -> Field' [Char]
xField (forall a. Set a -> [a]
Set.toList (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription (Set XField)
S.xFields SourceDebDescription
src)) forall a. [a] -> [a] -> [a]
++
            forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"X-Description" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription (Maybe Text)
S.xDescription SourceDebDescription
src)) forall a. a -> [a] -> [a]
:
           forall a b. (a -> b) -> [a] -> [b]
List.map BinaryDebDescription -> Paragraph' [Char]
binary (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' SourceDebDescription [BinaryDebDescription]
S.binaryPackages SourceDebDescription
src))
    }
    where
      binary :: B.BinaryDebDescription -> Paragraph' String
      binary :: BinaryDebDescription -> Paragraph' [Char]
binary BinaryDebDescription
bin =
          forall a. [Field' a] -> Paragraph' a
Paragraph
           ([forall a. (a, a) -> Field' a
Field ([Char]
"Package", [Char]
" " forall a. [a] -> [a] -> [a]
++ (forall a. Show a => a -> [Char]
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Pretty (PP a) => a -> Doc
ppPrint 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' BinaryDebDescription BinPkgName
B.package forall a b. (a -> b) -> a -> b
$ BinaryDebDescription
bin)),
             forall a. (a, a) -> Field' a
Field ([Char]
"Architecture", [Char]
" " forall a. [a] -> [a] -> [a]
++ (forall a. Show a => a -> [Char]
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc
empty forall a. Pretty (PP a) => a -> Doc
ppPrint 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' BinaryDebDescription (Maybe PackageArchitectures)
B.architecture forall a b. (a -> b) -> a -> b
$ BinaryDebDescription
bin))] forall a. [a] -> [a] -> [a]
++
            forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Multi-Arch" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BinaryDebDescription (Maybe MultiArch)
B.multiArch BinaryDebDescription
bin) forall a. [a] -> [a] -> [a]
++
            forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Section" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BinaryDebDescription (Maybe Section)
B.binarySection BinaryDebDescription
bin) forall a. [a] -> [a] -> [a]
++
            forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Priority" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BinaryDebDescription (Maybe PackagePriority)
B.binaryPriority BinaryDebDescription
bin) forall a. [a] -> [a] -> [a]
++
            forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Essential" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BinaryDebDescription (Maybe Bool)
B.essential BinaryDebDescription
bin) forall a. [a] -> [a] -> [a]
++
            PackageRelations -> [Field' [Char]]
relFields (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BinaryDebDescription PackageRelations
B.relations BinaryDebDescription
bin) forall a. [a] -> [a] -> [a]
++
            [forall a. (a, a) -> Field' a
Field ([Char]
"Description", [Char]
" " forall a. [a] -> [a] -> [a]
++ (Text -> [Char]
unpack forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
ensureDescription forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe forall a. Monoid a => a
mempty 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' BinaryDebDescription (Maybe Text)
B.description forall a b. (a -> b) -> a -> b
$ BinaryDebDescription
bin))])
          where
            ensureDescription :: Text -> Text
ensureDescription Text
t =
                case forall a. (a -> Bool) -> [a] -> [a]
List.dropWhileEnd Text -> Bool
Text.null (forall a. (a -> Bool) -> [a] -> [a]
List.dropWhile Text -> Bool
Text.null (forall a b. (a -> b) -> [a] -> [b]
List.map ((Char -> Bool) -> Text -> Text
Text.dropWhileEnd Char -> Bool
isSpace) (Text -> [Text]
Text.lines Text
t))) of
                  [] -> Text
"WARNING: No description available for package " forall a. Semigroup a => a -> a -> a
<> forall a. Pretty (PP a) => a -> Text
ppText (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BinaryDebDescription BinPkgName
B.package BinaryDebDescription
bin)
                  (Text
short : [Text]
long) ->
                      Text -> [Text] -> Text
Text.intercalate Text
"\n"
                        ((if Text -> Bool
Text.null ((Char -> Bool) -> Text -> Text
Text.dropWhile Char -> Bool
isSpace Text
short) then (Text
"WARNING: No short description available for package " forall a. Semigroup a => a -> a -> a
<> forall a. Pretty (PP a) => a -> Text
ppText (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' BinaryDebDescription BinPkgName
B.package BinaryDebDescription
bin)) else Text
short) forall a. a -> [a] -> [a]
: [Text]
long)
      mField :: [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
tag = forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\ a
x -> [forall a. (a, a) -> Field' a
Field ([Char]
tag, [Char]
" " forall a. Semigroup a => a -> a -> a
<> (forall a. Show a => a -> [Char]
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Pretty (PP a) => a -> Doc
ppPrint forall a b. (a -> b) -> a -> b
$ a
x))])
      lField :: [Char] -> [a] -> [Field' [Char]]
lField [Char]
_ [] = []
      lField [Char]
tag [a]
xs = [forall a. (a, a) -> Field' a
Field ([Char]
tag, [Char]
" " forall a. Semigroup a => a -> a -> a
<> (forall a. Show a => a -> [Char]
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Pretty (PP a) => a -> Doc
ppPrint forall a b. (a -> b) -> a -> b
$ [a]
xs))]
      vcsField :: VersionControlSpec -> Field' [Char]
vcsField (S.VCSBrowser Text
t) = forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Browser", [Char]
" " forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSArch Text
t) = forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Arch", [Char]
" " forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSBzr Text
t) = forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Bzr", [Char]
" " forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSCvs Text
t) = forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Cvs", [Char]
" " forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSDarcs Text
t) = forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Darcs", [Char]
" " forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSGit Text
t) = forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Git", [Char]
" " forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSHg Text
t) = forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Hg", [Char]
" " forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSMtn Text
t) = forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Mtn", [Char]
" " forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSSvn Text
t) = forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Svn", [Char]
" " forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      xField :: XField -> Field' [Char]
xField (S.XField Set XFieldDest
dests Text
tag Text
t) = forall a. (a, a) -> Field' a
Field (Text -> [Char]
unpack (Text
"X" forall a. Semigroup a => a -> a -> a
<> forall {a}. (IsString a, Semigroup a) => Set XFieldDest -> a
showDests Set XFieldDest
dests forall a. Semigroup a => a -> a -> a
<> Text
"-" forall a. Semigroup a => a -> a -> a
<> Text
tag), Text -> [Char]
unpack (Text
" " forall a. Semigroup a => a -> a -> a
<> Text
t))
      showDests :: Set XFieldDest -> a
showDests Set XFieldDest
s = if forall a. Ord a => a -> Set a -> Bool
member XFieldDest
S.B Set XFieldDest
s then a
"B" else a
"" forall a. Semigroup a => a -> a -> a
<>
                    if forall a. Ord a => a -> Set a -> Bool
member XFieldDest
S.S Set XFieldDest
s then a
"S" else a
"" forall a. Semigroup a => a -> a -> a
<>
                    if forall a. Ord a => a -> Set a -> Bool
member XFieldDest
S.C Set XFieldDest
s then a
"C" else a
""

relFields :: B.PackageRelations -> [Field' [Char]]
relFields :: PackageRelations -> [Field' [Char]]
relFields PackageRelations
rels =
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Depends" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' PackageRelations Relations
B.depends PackageRelations
rels) forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Recommends" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' PackageRelations Relations
B.recommends PackageRelations
rels) forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Suggests" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' PackageRelations Relations
B.suggests PackageRelations
rels) forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Pre-Depends" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' PackageRelations Relations
B.preDepends PackageRelations
rels) forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Breaks" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' PackageRelations Relations
B.breaks PackageRelations
rels) forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Conflicts" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' PackageRelations Relations
B.conflicts PackageRelations
rels) forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Provides" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' PackageRelations Relations
B.provides PackageRelations
rels) forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Replaces" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' PackageRelations Relations
B.replaces PackageRelations
rels) forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Built-Using" (forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Lens' PackageRelations Relations
B.builtUsing PackageRelations
rels)

depField :: [Char] -> Relations -> [Field' [Char]]
depField :: [Char] -> Relations -> [Field' [Char]]
depField [Char]
tag Relations
rels = case Relations
rels of [] -> []; Relations
_ -> [forall a. (a, a) -> Field' a
Field ([Char]
tag, [Char]
" " forall a. [a] -> [a] -> [a]
++ Relations -> [Char]
showDeps' Relations
rels)]