-- | 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 ([Char] -> Doc) -> (PP Bool -> [Char]) -> PP Bool -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> [Char]
forall a. Show a => a -> [Char]
show (Bool -> [Char]) -> (PP Bool -> Bool) -> PP Bool -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PP Bool -> Bool
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 =
    ([([Char], Text)] -> Map [Char] Text)
-> StateT DebInfo m [([Char], Text)]
-> StateT DebInfo m (Map [Char] Text)
forall a b. (a -> b) -> StateT DebInfo m a -> StateT DebInfo m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (([Char] -> Text -> Text -> Text)
-> [([Char], Text)] -> Map [Char] Text
forall k a. Ord k => (k -> a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWithKey (\ [Char]
k Text
a Text
b -> [Char] -> Text
forall a. HasCallStack => [Char] -> a
error ([Char] -> Text) -> [Char] -> Text
forall a b. (a -> b) -> a -> b
$ [Char]
"Multiple values for " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
k [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
":\n  " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
a [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\n" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
forall a. Show a => a -> [Char]
show Text
b)) (StateT DebInfo m [([Char], Text)]
 -> StateT DebInfo m (Map [Char] Text))
-> StateT DebInfo m [([Char], Text)]
-> StateT DebInfo m (Map [Char] Text)
forall a b. (a -> b) -> a -> b
$ WriterT [([Char], Text)] (StateT DebInfo m) ()
-> StateT DebInfo m [([Char], Text)]
forall (m :: * -> *) w a. Monad m => WriterT w m a -> m w
execWriterT (WriterT [([Char], Text)] (StateT DebInfo m) ()
 -> StateT DebInfo m [([Char], Text)])
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
-> StateT DebInfo m [([Char], Text)]
forall a b. (a -> b) -> a -> b
$
    do -- here <- liftIO getCurrentDirectory
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
control
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
changelog
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). MonadFail m => FilesT m [([Char], Text)]
rules
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
compat
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
copyright
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
sourceFormatFiles
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
watchFile
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
installs
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
dirs
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
init
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
logrotate
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
links
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
postinstFiles
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
postrmFiles
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
preinstFiles
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
prermFiles
       [([Char], Text)] -> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell ([([Char], Text)]
 -> WriterT [([Char], Text)] (StateT DebInfo m) ())
-> WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
-> WriterT [([Char], Text)] (StateT DebInfo m) ()
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< WriterT [([Char], Text)] (StateT DebInfo m) [([Char], Text)]
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 <- DebianT m SourceFormat
-> WriterT [([Char], Text)] (DebianT m) SourceFormat
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (DebianT m SourceFormat
 -> WriterT [([Char], Text)] (DebianT m) SourceFormat)
-> DebianT m SourceFormat
-> WriterT [([Char], Text)] (DebianT m) SourceFormat
forall a b. (a -> b) -> a -> b
$ Getting SourceFormat DebInfo SourceFormat -> DebianT m SourceFormat
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting SourceFormat DebInfo SourceFormat
Lens' DebInfo SourceFormat
D.sourceFormat
    [([Char], Text)] -> FilesT m [([Char], Text)]
forall a. a -> WriterT [([Char], Text)] (DebianT m) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([([Char], Text)] -> FilesT m [([Char], Text)])
-> [([Char], Text)] -> FilesT m [([Char], Text)]
forall a b. (a -> b) -> a -> b
$ [([Char]
"debian/source/format", [Char] -> Text
pack ([Char] -> Text)
-> (SourceFormat -> [Char]) -> SourceFormat -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceFormat -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow (SourceFormat -> Text) -> SourceFormat -> Text
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 = [([Char], Text)]
-> (Text -> [([Char], Text)]) -> Maybe Text -> [([Char], Text)]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\ Text
x -> [([Char]
"debian/watch", Text
x)]) (Maybe Text -> [([Char], Text)])
-> WriterT [([Char], Text)] (DebianT m) (Maybe Text)
-> WriterT [([Char], Text)] (DebianT m) [([Char], Text)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DebianT m (Maybe Text)
-> WriterT [([Char], Text)] (DebianT m) (Maybe Text)
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (DebianT m (Maybe Text)
 -> WriterT [([Char], Text)] (DebianT m) (Maybe Text))
-> DebianT m (Maybe Text)
-> WriterT [([Char], Text)] (DebianT m) (Maybe Text)
forall a b. (a -> b) -> a -> b
$ Getting (Maybe Text) DebInfo (Maybe Text) -> DebianT m (Maybe Text)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting (Maybe Text) DebInfo (Maybe Text)
Lens' DebInfo (Maybe Text)
D.watch)

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

installs :: (Monad m) => FilesT m [(FilePath, Text)]
installs :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
installs =
    (Map [Char] Text -> [([Char], Text)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map [Char] Text -> [([Char], Text)])
-> (Set Atom -> Map [Char] Text) -> Set Atom -> [([Char], Text)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Text) -> Map [Char] [Text] -> Map [Char] Text
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map [Text] -> Text
unlines (Map [Char] [Text] -> Map [Char] Text)
-> (Set Atom -> Map [Char] [Text]) -> Set Atom -> Map [Char] Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Atom -> Map [Char] [Text] -> Map [Char] [Text])
-> Map [Char] [Text] -> Set Atom -> Map [Char] [Text]
forall a b. (a -> b -> b) -> b -> Set a -> b
Set.fold Atom -> Map [Char] [Text] -> Map [Char] [Text]
doAtom Map [Char] [Text]
forall a. Monoid a => a
mempty) (Set Atom -> [([Char], Text)])
-> WriterT [([Char], Text)] (DebianT m) (Set Atom)
-> WriterT [([Char], Text)] (DebianT m) [([Char], Text)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DebianT m (Set Atom)
-> WriterT [([Char], Text)] (DebianT m) (Set Atom)
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (DebianT m (Set Atom)
 -> WriterT [([Char], Text)] (DebianT m) (Set Atom))
-> DebianT m (Set Atom)
-> WriterT [([Char], Text)] (DebianT m) (Set Atom)
forall a b. (a -> b) -> a -> b
$ Getting (Set Atom) DebInfo (Set Atom) -> DebianT m (Set Atom)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Getting (Set Atom) DebInfo (Set Atom)
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 = ([Text] -> [Text] -> [Text])
-> [Char] -> [Text] -> Map [Char] [Text] -> Map [Char] [Text]
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
(++) (BinPkgName -> [Char]
forall a. Pretty (PP a) => a -> [Char]
pathf BinPkgName
b) [[Char] -> Text
pack ([Char] -> [Char]
escapeDebianWildcards [Char]
frm [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
" " [Char] -> [Char] -> [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]
</> Doc -> [Char]
forall a. Show a => a -> [Char]
show (a -> Doc
forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
".install"

dirs :: (Monad m) => FilesT m [(FilePath, Text)]
dirs :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
dirs =
    (Map [Char] Text -> [([Char], Text)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map [Char] Text -> [([Char], Text)])
-> (Set Atom -> Map [Char] Text) -> Set Atom -> [([Char], Text)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Text) -> Map [Char] [Text] -> Map [Char] Text
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map [Text] -> Text
unlines (Map [Char] [Text] -> Map [Char] Text)
-> (Set Atom -> Map [Char] [Text]) -> Set Atom -> Map [Char] Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Atom -> Map [Char] [Text] -> Map [Char] [Text])
-> Map [Char] [Text] -> Set Atom -> Map [Char] [Text]
forall a b. (a -> b -> b) -> b -> Set a -> b
Set.fold Atom -> Map [Char] [Text] -> Map [Char] [Text]
doAtom Map [Char] [Text]
forall a. Monoid a => a
mempty) (Set Atom -> [([Char], Text)])
-> WriterT [([Char], Text)] (DebianT m) (Set Atom)
-> WriterT [([Char], Text)] (DebianT m) [([Char], Text)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DebianT m (Set Atom)
-> WriterT [([Char], Text)] (DebianT m) (Set Atom)
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (DebianT m (Set Atom)
 -> WriterT [([Char], Text)] (DebianT m) (Set Atom))
-> DebianT m (Set Atom)
-> WriterT [([Char], Text)] (DebianT m) (Set Atom)
forall a b. (a -> b) -> a -> b
$ Getting (Set Atom) DebInfo (Set Atom) -> DebianT m (Set Atom)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting (Set Atom) DebInfo (Set Atom)
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 = ([Text] -> [Text] -> [Text])
-> [Char] -> [Text] -> Map [Char] [Text] -> Map [Char] [Text]
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
(++) (BinPkgName -> [Char]
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]
</> Doc -> [Char]
forall a. Show a => a -> [Char]
show (a -> Doc
forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
".dirs"

init :: (Monad m) => FilesT m [(FilePath, Text)]
init :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
init =
    (Map [Char] Text -> [([Char], Text)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map [Char] Text -> [([Char], Text)])
-> (Map BinPkgName Text -> Map [Char] Text)
-> Map BinPkgName Text
-> [([Char], Text)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (BinPkgName -> [Char]) -> Map BinPkgName Text -> Map [Char] Text
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
mapKeys BinPkgName -> [Char]
forall a. Pretty (PP a) => a -> [Char]
pathf) (Map BinPkgName Text -> [([Char], Text)])
-> WriterT [([Char], Text)] (DebianT m) (Map BinPkgName Text)
-> WriterT [([Char], Text)] (DebianT m) [([Char], Text)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DebianT m (Map BinPkgName Text)
-> WriterT [([Char], Text)] (DebianT m) (Map BinPkgName Text)
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (DebianT m (Map BinPkgName Text)
 -> WriterT [([Char], Text)] (DebianT m) (Map BinPkgName Text))
-> DebianT m (Map BinPkgName Text)
-> WriterT [([Char], Text)] (DebianT m) (Map BinPkgName Text)
forall a b. (a -> b) -> a -> b
$ Getting (Map BinPkgName Text) DebInfo (Map BinPkgName Text)
-> DebianT m (Map BinPkgName Text)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting (Map BinPkgName Text) DebInfo (Map BinPkgName Text)
Lens' DebInfo (Map BinPkgName Text)
D.installInit)
    where
      pathf :: a -> [Char]
pathf a
name = [Char]
"debian" [Char] -> [Char] -> [Char]
</> Doc -> [Char]
forall a. Show a => a -> [Char]
show (a -> Doc
forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) [Char] -> [Char] -> [Char]
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 =
    (Map [Char] Text -> [([Char], Text)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map [Char] Text -> [([Char], Text)])
-> (Map BinPkgName (Set Text) -> Map [Char] Text)
-> Map BinPkgName (Set Text)
-> [([Char], Text)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Text -> Text) -> Map [Char] (Set Text) -> Map [Char] Text
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map (\ Set Text
stanzas -> [Text] -> Text
Text.unlines (Set Text -> [Text]
forall a. Set a -> [a]
Set.toList Set Text
stanzas)) (Map [Char] (Set Text) -> Map [Char] Text)
-> (Map BinPkgName (Set Text) -> Map [Char] (Set Text))
-> Map BinPkgName (Set Text)
-> Map [Char] Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (BinPkgName -> [Char])
-> Map BinPkgName (Set Text) -> Map [Char] (Set Text)
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
mapKeys BinPkgName -> [Char]
forall a. Pretty (PP a) => a -> [Char]
pathf) (Map BinPkgName (Set Text) -> [([Char], Text)])
-> WriterT [([Char], Text)] (DebianT m) (Map BinPkgName (Set Text))
-> WriterT [([Char], Text)] (DebianT m) [([Char], Text)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DebianT m (Map BinPkgName (Set Text))
-> WriterT [([Char], Text)] (DebianT m) (Map BinPkgName (Set Text))
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (DebianT m (Map BinPkgName (Set Text))
 -> WriterT
      [([Char], Text)] (DebianT m) (Map BinPkgName (Set Text)))
-> DebianT m (Map BinPkgName (Set Text))
-> WriterT [([Char], Text)] (DebianT m) (Map BinPkgName (Set Text))
forall a b. (a -> b) -> a -> b
$ Getting
  (Map BinPkgName (Set Text)) DebInfo (Map BinPkgName (Set Text))
-> DebianT m (Map BinPkgName (Set Text))
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting
  (Map BinPkgName (Set Text)) DebInfo (Map BinPkgName (Set Text))
Lens' DebInfo (Map BinPkgName (Set Text))
D.logrotateStanza)
    where
      pathf :: a -> [Char]
pathf a
name = [Char]
"debian" [Char] -> [Char] -> [Char]
</> Doc -> [Char]
forall a. Show a => a -> [Char]
show (a -> Doc
forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) [Char] -> [Char] -> [Char]
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 =
    (Map [Char] Text -> [([Char], Text)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map [Char] Text -> [([Char], Text)])
-> (Set Atom -> Map [Char] Text) -> Set Atom -> [([Char], Text)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Text] -> Text) -> Map [Char] [Text] -> Map [Char] Text
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map [Text] -> Text
unlines (Map [Char] [Text] -> Map [Char] Text)
-> (Set Atom -> Map [Char] [Text]) -> Set Atom -> Map [Char] Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Atom -> Map [Char] [Text] -> Map [Char] [Text])
-> Map [Char] [Text] -> Set Atom -> Map [Char] [Text]
forall a b. (a -> b -> b) -> b -> Set a -> b
Set.fold Atom -> Map [Char] [Text] -> Map [Char] [Text]
doAtom Map [Char] [Text]
forall a. Monoid a => a
mempty) (Set Atom -> [([Char], Text)])
-> WriterT [([Char], Text)] (DebianT m) (Set Atom)
-> WriterT [([Char], Text)] (DebianT m) [([Char], Text)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DebianT m (Set Atom)
-> WriterT [([Char], Text)] (DebianT m) (Set Atom)
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (DebianT m (Set Atom)
 -> WriterT [([Char], Text)] (DebianT m) (Set Atom))
-> DebianT m (Set Atom)
-> WriterT [([Char], Text)] (DebianT m) (Set Atom)
forall a b. (a -> b) -> a -> b
$ Getting (Set Atom) DebInfo (Set Atom) -> DebianT m (Set Atom)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting (Set Atom) DebInfo (Set Atom)
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 = ([Text] -> [Text] -> [Text])
-> [Char] -> [Text] -> Map [Char] [Text] -> Map [Char] [Text]
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
(++) (BinPkgName -> [Char]
forall a. Pretty (PP a) => a -> [Char]
pathf BinPkgName
b) [[Char] -> Text
pack [Char]
loc Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack [Char]
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]
</> Doc -> [Char]
forall a. Show a => a -> [Char]
show (a -> Doc
forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
".links"

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

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

prermFiles :: (Monad m) => FilesT m [(FilePath, Text)]
prermFiles :: forall (m :: * -> *). Monad m => FilesT m [([Char], Text)]
prermFiles =
    (Map [Char] Text -> [([Char], Text)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map [Char] Text -> [([Char], Text)])
-> (Map BinPkgName Text -> Map [Char] Text)
-> Map BinPkgName Text
-> [([Char], Text)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (BinPkgName -> [Char]) -> Map BinPkgName Text -> Map [Char] Text
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
mapKeys BinPkgName -> [Char]
forall a. Pretty (PP a) => a -> [Char]
pathf) (Map BinPkgName Text -> [([Char], Text)])
-> WriterT [([Char], Text)] (DebianT m) (Map BinPkgName Text)
-> WriterT [([Char], Text)] (DebianT m) [([Char], Text)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DebianT m (Map BinPkgName Text)
-> WriterT [([Char], Text)] (DebianT m) (Map BinPkgName Text)
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (DebianT m (Map BinPkgName Text)
 -> WriterT [([Char], Text)] (DebianT m) (Map BinPkgName Text))
-> DebianT m (Map BinPkgName Text)
-> WriterT [([Char], Text)] (DebianT m) (Map BinPkgName Text)
forall a b. (a -> b) -> a -> b
$ Getting (Map BinPkgName Text) DebInfo (Map BinPkgName Text)
-> DebianT m (Map BinPkgName Text)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting (Map BinPkgName Text) DebInfo (Map BinPkgName Text)
Lens' DebInfo (Map BinPkgName Text)
D.preRm)
    where
      pathf :: a -> [Char]
pathf a
name = [Char]
"debian" [Char] -> [Char] -> [Char]
</> Doc -> [Char]
forall a. Show a => a -> [Char]
show (a -> Doc
forall a. Pretty (PP a) => a -> Doc
ppPrint a
name) [Char] -> [Char] -> [Char]
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 <- DebianT m (Maybe Text)
-> WriterT [([Char], Text)] (DebianT m) (Maybe Text)
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Getting (Maybe Text) DebInfo (Maybe Text) -> DebianT m (Maybe Text)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Getting (Maybe Text) DebInfo (Maybe Text)
Lens' DebInfo (Maybe Text)
D.rulesHead))
       Text
rassignments <- DebianT m [Text] -> WriterT [([Char], Text)] (DebianT m) [Text]
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Getting [Text] DebInfo [Text] -> DebianT m [Text]
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Getting [Text] DebInfo [Text]
Lens' DebInfo [Text]
D.rulesSettings)) WriterT [([Char], Text)] (DebianT m) [Text]
-> ([Text] -> WriterT [([Char], Text)] (DebianT m) Text)
-> WriterT [([Char], Text)] (DebianT m) Text
forall a b.
WriterT [([Char], Text)] (DebianT m) a
-> (a -> WriterT [([Char], Text)] (DebianT m) b)
-> WriterT [([Char], Text)] (DebianT m) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> WriterT [([Char], Text)] (DebianT m) Text
forall a. a -> WriterT [([Char], Text)] (DebianT m) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> WriterT [([Char], Text)] (DebianT m) Text)
-> ([Text] -> Text)
-> [Text]
-> WriterT [([Char], Text)] (DebianT m) Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Text] -> Text
intercalate Text
"\n"
       Text
rincludes <- DebianT m [Text] -> WriterT [([Char], Text)] (DebianT m) [Text]
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Getting [Text] DebInfo [Text] -> DebianT m [Text]
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Getting [Text] DebInfo [Text]
Lens' DebInfo [Text]
D.rulesIncludes)) WriterT [([Char], Text)] (DebianT m) [Text]
-> ([Text] -> WriterT [([Char], Text)] (DebianT m) Text)
-> WriterT [([Char], Text)] (DebianT m) Text
forall a b.
WriterT [([Char], Text)] (DebianT m) a
-> (a -> WriterT [([Char], Text)] (DebianT m) b)
-> WriterT [([Char], Text)] (DebianT m) b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> WriterT [([Char], Text)] (DebianT m) Text
forall a. a -> WriterT [([Char], Text)] (DebianT m) a
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> WriterT [([Char], Text)] (DebianT m) Text)
-> ([Text] -> Text)
-> [Text]
-> WriterT [([Char], Text)] (DebianT m) Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Text] -> Text
intercalate Text
"\n"
       [Text]
rl <- ([Text] -> [Text]
forall a. [a] -> [a]
reverse ([Text] -> [Text]) -> (Set Text -> [Text]) -> Set Text -> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set Text -> [Text]
forall a. Set a -> [a]
Set.toList) (Set Text -> [Text])
-> WriterT [([Char], Text)] (DebianT m) (Set Text)
-> WriterT [([Char], Text)] (DebianT m) [Text]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DebianT m (Set Text)
-> WriterT [([Char], Text)] (DebianT m) (Set Text)
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Getting (Set Text) DebInfo (Set Text) -> DebianT m (Set Text)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Getting (Set Text) DebInfo (Set Text)
Lens' DebInfo (Set Text)
D.rulesFragments))
       [([Char], Text)] -> FilesT m [([Char], Text)]
forall a. a -> WriterT [([Char], Text)] (DebianT m) a
forall (m :: * -> *) a. Monad m => a -> m a
return [([Char]
"debian/rules", Text -> [Text] -> Text
intercalate Text
"\n\n" ((Text -> Bool) -> [Text] -> [Text]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (Text -> Bool) -> Text -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Bool
Text.null) ((Text -> Text) -> [Text] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
List.map Text -> Text
strip (Text
rh Text -> [Text] -> [Text]
forall a. a -> [a] -> [a]
: Text
rassignments Text -> [Text] -> [Text]
forall a. a -> [a] -> [a]
: Text
rincludes Text -> [Text] -> [Text]
forall a. a -> [a] -> [a]
: [Text]
rl))) Text -> Text -> Text
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 <- DebianT m (Maybe ChangeLog)
-> WriterT [([Char], Text)] (DebianT m) (Maybe ChangeLog)
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (DebianT m (Maybe ChangeLog)
 -> WriterT [([Char], Text)] (DebianT m) (Maybe ChangeLog))
-> DebianT m (Maybe ChangeLog)
-> WriterT [([Char], Text)] (DebianT m) (Maybe ChangeLog)
forall a b. (a -> b) -> a -> b
$ Getting (Maybe ChangeLog) DebInfo (Maybe ChangeLog)
-> DebianT m (Maybe ChangeLog)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting (Maybe ChangeLog) DebInfo (Maybe ChangeLog)
Lens' DebInfo (Maybe ChangeLog)
D.changelog
       [([Char], Text)] -> FilesT m [([Char], Text)]
forall a. a -> WriterT [([Char], Text)] (DebianT m) a
forall (m :: * -> *) a. Monad m => a -> m a
return [([Char]
"debian/changelog", [Char] -> Text
pack (Doc -> [Char]
forall a. Show a => a -> [Char]
show (ChangeLog -> Doc
forall a. Pretty (PP a) => a -> Doc
ppPrint (ChangeLog -> Maybe ChangeLog -> ChangeLog
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> ChangeLog
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 <- DebianT m SourceDebDescription
-> WriterT [([Char], Text)] (DebianT m) SourceDebDescription
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (DebianT m SourceDebDescription
 -> WriterT [([Char], Text)] (DebianT m) SourceDebDescription)
-> DebianT m SourceDebDescription
-> WriterT [([Char], Text)] (DebianT m) SourceDebDescription
forall a b. (a -> b) -> a -> b
$ Getting SourceDebDescription DebInfo SourceDebDescription
-> DebianT m SourceDebDescription
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting SourceDebDescription DebInfo SourceDebDescription
Lens' DebInfo SourceDebDescription
D.control
       [([Char], Text)] -> FilesT m [([Char], Text)]
forall a. a -> WriterT [([Char], Text)] (DebianT m) a
forall (m :: * -> *) a. Monad m => a -> m a
return [([Char]
"debian/control", Control' [Char] -> Text
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 <- DebianT m (Maybe Int)
-> WriterT [([Char], Text)] (DebianT m) (Maybe Int)
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (DebianT m (Maybe Int)
 -> WriterT [([Char], Text)] (DebianT m) (Maybe Int))
-> DebianT m (Maybe Int)
-> WriterT [([Char], Text)] (DebianT m) (Maybe Int)
forall a b. (a -> b) -> a -> b
$ Getting (Maybe Int) DebInfo (Maybe Int) -> DebianT m (Maybe Int)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use Getting (Maybe Int) DebInfo (Maybe Int)
Lens' DebInfo (Maybe Int)
D.compat
       [([Char], Text)] -> FilesT m [([Char], Text)]
forall a. a -> WriterT [([Char], Text)] (DebianT m) a
forall (m :: * -> *) a. Monad m => a -> m a
return [([Char]
"debian/compat", [Char] -> Text
pack (Int -> [Char]
forall a. Show a => a -> [Char]
show (Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe ([Char] -> Int
forall a. HasCallStack => [Char] -> a
error [Char]
"Missing DebCompat atom - is debhelper installed?") (Maybe Int -> Int) -> Maybe Int -> Int
forall a b. (a -> b) -> a -> b
$ Maybe Int
t) [Char] -> [Char] -> [Char]
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 <- DebianT m (Maybe CopyrightDescription)
-> WriterT
     [([Char], Text)] (DebianT m) (Maybe CopyrightDescription)
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [([Char], Text)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (DebianT m (Maybe CopyrightDescription)
 -> WriterT
      [([Char], Text)] (DebianT m) (Maybe CopyrightDescription))
-> DebianT m (Maybe CopyrightDescription)
-> WriterT
     [([Char], Text)] (DebianT m) (Maybe CopyrightDescription)
forall a b. (a -> b) -> a -> b
$ Getting
  (Maybe CopyrightDescription) DebInfo (Maybe CopyrightDescription)
-> DebianT m (Maybe CopyrightDescription)
forall s (m :: * -> *) a. MonadState s m => Getting a s a -> m a
use (Getting
  (Maybe CopyrightDescription) DebInfo (Maybe CopyrightDescription)
Lens' DebInfo (Maybe CopyrightDescription)
D.copyright)
       [([Char], Text)] -> FilesT m [([Char], Text)]
forall a. a -> WriterT [([Char], Text)] (DebianT m) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([([Char], Text)] -> FilesT m [([Char], Text)])
-> [([Char], Text)] -> FilesT m [([Char], Text)]
forall a b. (a -> b) -> a -> b
$ [([Char], Text)]
-> (CopyrightDescription -> [([Char], Text)])
-> Maybe CopyrightDescription
-> [([Char], Text)]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\ CopyrightDescription
x -> [([Char]
"debian/copyright", CopyrightDescription -> Text
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 =
          ([Field' [Char]] -> Paragraph' [Char]
forall a. [Field' a] -> Paragraph' a
Paragraph
           ([([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Source", [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (Doc -> [Char]
forall a. Show a => a -> [Char]
show (Doc -> [Char])
-> (SourceDebDescription -> Doc) -> SourceDebDescription -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> (SrcPkgName -> Doc) -> Maybe SrcPkgName -> Doc
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc
empty SrcPkgName -> Doc
forall a. Pretty (PP a) => a -> Doc
ppPrint (Maybe SrcPkgName -> Doc)
-> (SourceDebDescription -> Maybe SrcPkgName)
-> SourceDebDescription
-> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting (Maybe SrcPkgName) SourceDebDescription (Maybe SrcPkgName)
-> SourceDebDescription -> Maybe SrcPkgName
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe SrcPkgName) SourceDebDescription (Maybe SrcPkgName)
Lens' SourceDebDescription (Maybe SrcPkgName)
S.source (SourceDebDescription -> [Char]) -> SourceDebDescription -> [Char]
forall a b. (a -> b) -> a -> b
$ SourceDebDescription
src)),
             ([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Maintainer", [Char]
" " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> (NameAddr -> [Char]
forall a. Pretty (PP a) => a -> [Char]
ppShow (NameAddr -> [Char])
-> (SourceDebDescription -> NameAddr)
-> SourceDebDescription
-> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> NameAddr)
-> (NameAddr -> NameAddr) -> Either [Char] NameAddr -> NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (NameAddr -> [Char] -> NameAddr
forall a b. a -> b -> a
const NameAddr
maintainerOfLastResort) NameAddr -> NameAddr
forall a. a -> a
id (Either [Char] NameAddr -> NameAddr)
-> (SourceDebDescription -> Either [Char] NameAddr)
-> SourceDebDescription
-> NameAddr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting
  (Either [Char] NameAddr)
  SourceDebDescription
  (Either [Char] NameAddr)
-> SourceDebDescription -> Either [Char] NameAddr
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting
  (Either [Char] NameAddr)
  SourceDebDescription
  (Either [Char] NameAddr)
Lens' SourceDebDescription (Either [Char] NameAddr)
S.maintainer (SourceDebDescription -> [Char]) -> SourceDebDescription -> [Char]
forall a b. (a -> b) -> a -> b
$ SourceDebDescription
src))] [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> [NameAddr] -> [Field' [Char]]
forall {a}. Pretty (PP [a]) => [Char] -> [a] -> [Field' [Char]]
lField [Char]
"Uploaders" (Getting [NameAddr] SourceDebDescription [NameAddr]
-> SourceDebDescription -> [NameAddr]
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting [NameAddr] SourceDebDescription [NameAddr]
Lens' SourceDebDescription [NameAddr]
S.uploaders SourceDebDescription
src) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            (case Getting Bool SourceDebDescription Bool
-> SourceDebDescription -> Bool
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Bool SourceDebDescription Bool
Lens' SourceDebDescription Bool
S.dmUploadAllowed SourceDebDescription
src of Bool
True -> [([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"DM-Upload-Allowed", [Char]
" yes")]; Bool
False -> []) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Maybe PackagePriority -> [Field' [Char]]
forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Priority" (Getting
  (Maybe PackagePriority)
  SourceDebDescription
  (Maybe PackagePriority)
-> SourceDebDescription -> Maybe PackagePriority
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting
  (Maybe PackagePriority)
  SourceDebDescription
  (Maybe PackagePriority)
Lens' SourceDebDescription (Maybe PackagePriority)
S.priority SourceDebDescription
src) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Maybe Section -> [Field' [Char]]
forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Section" (Getting (Maybe Section) SourceDebDescription (Maybe Section)
-> SourceDebDescription -> Maybe Section
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe Section) SourceDebDescription (Maybe Section)
Lens' SourceDebDescription (Maybe Section)
S.section SourceDebDescription
src) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Rules-Requires-Root", (if Getting Bool SourceDebDescription Bool
-> SourceDebDescription -> Bool
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Bool SourceDebDescription Bool
Lens' SourceDebDescription Bool
S.rulesRequiresRoot SourceDebDescription
src then [Char]
" yes" else [Char]
" no"))] [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Build-Depends" (Getting Relations SourceDebDescription Relations
-> SourceDebDescription -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations SourceDebDescription Relations
Lens' SourceDebDescription Relations
S.buildDepends SourceDebDescription
src) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Build-Depends-Indep" (Getting Relations SourceDebDescription Relations
-> SourceDebDescription -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations SourceDebDescription Relations
Lens' SourceDebDescription Relations
S.buildDependsIndep SourceDebDescription
src) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Build-Conflicts" (Getting Relations SourceDebDescription Relations
-> SourceDebDescription -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations SourceDebDescription Relations
Lens' SourceDebDescription Relations
S.buildConflicts SourceDebDescription
src) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Build-Conflicts-Indep" (Getting Relations SourceDebDescription Relations
-> SourceDebDescription -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations SourceDebDescription Relations
Lens' SourceDebDescription Relations
S.buildConflictsIndep SourceDebDescription
src) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Maybe StandardsVersion -> [Field' [Char]]
forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Standards-Version" (Getting
  (Maybe StandardsVersion)
  SourceDebDescription
  (Maybe StandardsVersion)
-> SourceDebDescription -> Maybe StandardsVersion
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting
  (Maybe StandardsVersion)
  SourceDebDescription
  (Maybe StandardsVersion)
Lens' SourceDebDescription (Maybe StandardsVersion)
S.standardsVersion SourceDebDescription
src) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Maybe Text -> [Field' [Char]]
forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Homepage" (Getting (Maybe Text) SourceDebDescription (Maybe Text)
-> SourceDebDescription -> Maybe Text
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe Text) SourceDebDescription (Maybe Text)
Lens' SourceDebDescription (Maybe Text)
S.homepage SourceDebDescription
src) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            (VersionControlSpec -> Field' [Char])
-> [VersionControlSpec] -> [Field' [Char]]
forall a b. (a -> b) -> [a] -> [b]
List.map VersionControlSpec -> Field' [Char]
vcsField (Set VersionControlSpec -> [VersionControlSpec]
forall a. Set a -> [a]
Set.toList (Getting
  (Set VersionControlSpec)
  SourceDebDescription
  (Set VersionControlSpec)
-> SourceDebDescription -> Set VersionControlSpec
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting
  (Set VersionControlSpec)
  SourceDebDescription
  (Set VersionControlSpec)
Lens' SourceDebDescription (Set VersionControlSpec)
S.vcsFields SourceDebDescription
src)) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            (XField -> Field' [Char]) -> [XField] -> [Field' [Char]]
forall a b. (a -> b) -> [a] -> [b]
List.map XField -> Field' [Char]
xField (Set XField -> [XField]
forall a. Set a -> [a]
Set.toList (Getting (Set XField) SourceDebDescription (Set XField)
-> SourceDebDescription -> Set XField
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Set XField) SourceDebDescription (Set XField)
Lens' SourceDebDescription (Set XField)
S.xFields SourceDebDescription
src)) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Maybe Text -> [Field' [Char]]
forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"X-Description" (Getting (Maybe Text) SourceDebDescription (Maybe Text)
-> SourceDebDescription -> Maybe Text
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe Text) SourceDebDescription (Maybe Text)
Lens' SourceDebDescription (Maybe Text)
S.xDescription SourceDebDescription
src)) Paragraph' [Char] -> [Paragraph' [Char]] -> [Paragraph' [Char]]
forall a. a -> [a] -> [a]
:
           (BinaryDebDescription -> Paragraph' [Char])
-> [BinaryDebDescription] -> [Paragraph' [Char]]
forall a b. (a -> b) -> [a] -> [b]
List.map BinaryDebDescription -> Paragraph' [Char]
binary (Getting
  [BinaryDebDescription] SourceDebDescription [BinaryDebDescription]
-> SourceDebDescription -> [BinaryDebDescription]
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting
  [BinaryDebDescription] SourceDebDescription [BinaryDebDescription]
Lens' SourceDebDescription [BinaryDebDescription]
S.binaryPackages SourceDebDescription
src))
    }
    where
      binary :: B.BinaryDebDescription -> Paragraph' String
      binary :: BinaryDebDescription -> Paragraph' [Char]
binary BinaryDebDescription
bin =
          [Field' [Char]] -> Paragraph' [Char]
forall a. [Field' a] -> Paragraph' a
Paragraph
           ([([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Package", [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (Doc -> [Char]
forall a. Show a => a -> [Char]
show (Doc -> [Char])
-> (BinaryDebDescription -> Doc) -> BinaryDebDescription -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> Doc
forall a. Pretty (PP a) => a -> Doc
ppPrint (BinPkgName -> Doc)
-> (BinaryDebDescription -> BinPkgName)
-> BinaryDebDescription
-> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting BinPkgName BinaryDebDescription BinPkgName
-> BinaryDebDescription -> BinPkgName
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting BinPkgName BinaryDebDescription BinPkgName
Lens' BinaryDebDescription BinPkgName
B.package (BinaryDebDescription -> [Char]) -> BinaryDebDescription -> [Char]
forall a b. (a -> b) -> a -> b
$ BinaryDebDescription
bin)),
             ([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Architecture", [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (Doc -> [Char]
forall a. Show a => a -> [Char]
show (Doc -> [Char])
-> (BinaryDebDescription -> Doc) -> BinaryDebDescription -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc
-> (PackageArchitectures -> Doc)
-> Maybe PackageArchitectures
-> Doc
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc
empty PackageArchitectures -> Doc
forall a. Pretty (PP a) => a -> Doc
ppPrint (Maybe PackageArchitectures -> Doc)
-> (BinaryDebDescription -> Maybe PackageArchitectures)
-> BinaryDebDescription
-> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting
  (Maybe PackageArchitectures)
  BinaryDebDescription
  (Maybe PackageArchitectures)
-> BinaryDebDescription -> Maybe PackageArchitectures
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting
  (Maybe PackageArchitectures)
  BinaryDebDescription
  (Maybe PackageArchitectures)
Lens' BinaryDebDescription (Maybe PackageArchitectures)
B.architecture (BinaryDebDescription -> [Char]) -> BinaryDebDescription -> [Char]
forall a b. (a -> b) -> a -> b
$ BinaryDebDescription
bin))] [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Maybe MultiArch -> [Field' [Char]]
forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Multi-Arch" (Getting (Maybe MultiArch) BinaryDebDescription (Maybe MultiArch)
-> BinaryDebDescription -> Maybe MultiArch
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe MultiArch) BinaryDebDescription (Maybe MultiArch)
Lens' BinaryDebDescription (Maybe MultiArch)
B.multiArch BinaryDebDescription
bin) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Maybe Section -> [Field' [Char]]
forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Section" (Getting (Maybe Section) BinaryDebDescription (Maybe Section)
-> BinaryDebDescription -> Maybe Section
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe Section) BinaryDebDescription (Maybe Section)
Lens' BinaryDebDescription (Maybe Section)
B.binarySection BinaryDebDescription
bin) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Maybe PackagePriority -> [Field' [Char]]
forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Priority" (Getting
  (Maybe PackagePriority)
  BinaryDebDescription
  (Maybe PackagePriority)
-> BinaryDebDescription -> Maybe PackagePriority
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting
  (Maybe PackagePriority)
  BinaryDebDescription
  (Maybe PackagePriority)
Lens' BinaryDebDescription (Maybe PackagePriority)
B.binaryPriority BinaryDebDescription
bin) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [Char] -> Maybe Bool -> [Field' [Char]]
forall {a}. Pretty (PP a) => [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
"Essential" (Getting (Maybe Bool) BinaryDebDescription (Maybe Bool)
-> BinaryDebDescription -> Maybe Bool
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe Bool) BinaryDebDescription (Maybe Bool)
Lens' BinaryDebDescription (Maybe Bool)
B.essential BinaryDebDescription
bin) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            PackageRelations -> [Field' [Char]]
relFields (Getting PackageRelations BinaryDebDescription PackageRelations
-> BinaryDebDescription -> PackageRelations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting PackageRelations BinaryDebDescription PackageRelations
Lens' BinaryDebDescription PackageRelations
B.relations BinaryDebDescription
bin) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
            [([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Description", [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (Text -> [Char]
unpack (Text -> [Char])
-> (BinaryDebDescription -> Text) -> BinaryDebDescription -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
ensureDescription (Text -> Text)
-> (BinaryDebDescription -> Text) -> BinaryDebDescription -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
forall a. Monoid a => a
mempty (Maybe Text -> Text)
-> (BinaryDebDescription -> Maybe Text)
-> BinaryDebDescription
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Getting (Maybe Text) BinaryDebDescription (Maybe Text)
-> BinaryDebDescription -> Maybe Text
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting (Maybe Text) BinaryDebDescription (Maybe Text)
Lens' BinaryDebDescription (Maybe Text)
B.description (BinaryDebDescription -> [Char]) -> BinaryDebDescription -> [Char]
forall a b. (a -> b) -> a -> b
$ BinaryDebDescription
bin))])
          where
            ensureDescription :: Text -> Text
ensureDescription Text
t =
                case (Text -> Bool) -> [Text] -> [Text]
forall a. (a -> Bool) -> [a] -> [a]
List.dropWhileEnd Text -> Bool
Text.null ((Text -> Bool) -> [Text] -> [Text]
forall a. (a -> Bool) -> [a] -> [a]
List.dropWhile Text -> Bool
Text.null ((Text -> Text) -> [Text] -> [Text]
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 " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> BinPkgName -> Text
forall a. Pretty (PP a) => a -> Text
ppText (Getting BinPkgName BinaryDebDescription BinPkgName
-> BinaryDebDescription -> BinPkgName
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting BinPkgName BinaryDebDescription BinPkgName
Lens' BinaryDebDescription BinPkgName
B.package BinaryDebDescription
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 " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> BinPkgName -> Text
forall a. Pretty (PP a) => a -> Text
ppText (Getting BinPkgName BinaryDebDescription BinPkgName
-> BinaryDebDescription -> BinPkgName
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting BinPkgName BinaryDebDescription BinPkgName
Lens' BinaryDebDescription BinPkgName
B.package BinaryDebDescription
bin)) else Text
short) Text -> [Text] -> [Text]
forall a. a -> [a] -> [a]
: [Text]
long)
      mField :: [Char] -> Maybe a -> [Field' [Char]]
mField [Char]
tag = [Field' [Char]]
-> (a -> [Field' [Char]]) -> Maybe a -> [Field' [Char]]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\ a
x -> [([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
tag, [Char]
" " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> (Doc -> [Char]
forall a. Show a => a -> [Char]
show (Doc -> [Char]) -> (a -> Doc) -> a -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Doc
forall a. Pretty (PP a) => a -> Doc
ppPrint (a -> [Char]) -> a -> [Char]
forall a b. (a -> b) -> a -> b
$ a
x))])
      lField :: [Char] -> [a] -> [Field' [Char]]
lField [Char]
_ [] = []
      lField [Char]
tag [a]
xs = [([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
tag, [Char]
" " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> (Doc -> [Char]
forall a. Show a => a -> [Char]
show (Doc -> [Char]) -> ([a] -> Doc) -> [a] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Doc
forall a. Pretty (PP a) => a -> Doc
ppPrint ([a] -> [Char]) -> [a] -> [Char]
forall a b. (a -> b) -> a -> b
$ [a]
xs))]
      vcsField :: VersionControlSpec -> Field' [Char]
vcsField (S.VCSBrowser Text
t) = ([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Browser", [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSArch Text
t) = ([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Arch", [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSBzr Text
t) = ([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Bzr", [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSCvs Text
t) = ([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Cvs", [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSDarcs Text
t) = ([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Darcs", [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSGit Text
t) = ([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Git", [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSHg Text
t) = ([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Hg", [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSMtn Text
t) = ([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Mtn", [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
t)
      vcsField (S.VCSSvn Text
t) = ([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
"Vcs-Svn", [Char]
" " [Char] -> [Char] -> [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) = ([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field (Text -> [Char]
unpack (Text
"X" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Set XFieldDest -> Text
forall {a}. (IsString a, Semigroup a) => Set XFieldDest -> a
showDests Set XFieldDest
dests Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"-" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
tag), Text -> [Char]
unpack (Text
" " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
t))
      showDests :: Set XFieldDest -> a
showDests Set XFieldDest
s = if XFieldDest -> Set XFieldDest -> Bool
forall a. Ord a => a -> Set a -> Bool
member XFieldDest
S.B Set XFieldDest
s then a
"B" else a
"" a -> a -> a
forall a. Semigroup a => a -> a -> a
<>
                    if XFieldDest -> Set XFieldDest -> Bool
forall a. Ord a => a -> Set a -> Bool
member XFieldDest
S.S Set XFieldDest
s then a
"S" else a
"" a -> a -> a
forall a. Semigroup a => a -> a -> a
<>
                    if XFieldDest -> Set XFieldDest -> Bool
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" (Getting Relations PackageRelations Relations
-> PackageRelations -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations PackageRelations Relations
Lens' PackageRelations Relations
B.depends PackageRelations
rels) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Recommends" (Getting Relations PackageRelations Relations
-> PackageRelations -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations PackageRelations Relations
Lens' PackageRelations Relations
B.recommends PackageRelations
rels) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Suggests" (Getting Relations PackageRelations Relations
-> PackageRelations -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations PackageRelations Relations
Lens' PackageRelations Relations
B.suggests PackageRelations
rels) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Pre-Depends" (Getting Relations PackageRelations Relations
-> PackageRelations -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations PackageRelations Relations
Lens' PackageRelations Relations
B.preDepends PackageRelations
rels) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Breaks" (Getting Relations PackageRelations Relations
-> PackageRelations -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations PackageRelations Relations
Lens' PackageRelations Relations
B.breaks PackageRelations
rels) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Conflicts" (Getting Relations PackageRelations Relations
-> PackageRelations -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations PackageRelations Relations
Lens' PackageRelations Relations
B.conflicts PackageRelations
rels) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Provides" (Getting Relations PackageRelations Relations
-> PackageRelations -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations PackageRelations Relations
Lens' PackageRelations Relations
B.provides PackageRelations
rels) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Replaces" (Getting Relations PackageRelations Relations
-> PackageRelations -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations PackageRelations Relations
Lens' PackageRelations Relations
B.replaces PackageRelations
rels) [Field' [Char]] -> [Field' [Char]] -> [Field' [Char]]
forall a. [a] -> [a] -> [a]
++
    [Char] -> Relations -> [Field' [Char]]
depField [Char]
"Built-Using" (Getting Relations PackageRelations Relations
-> PackageRelations -> Relations
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Relations PackageRelations Relations
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
_ -> [([Char], [Char]) -> Field' [Char]
forall a. (a, a) -> Field' a
Field ([Char]
tag, [Char]
" " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Relations -> [Char]
showDeps' Relations
rels)]