-- | Code pulled out of cabal-debian that straightforwardly implements
-- parts of the Debian policy manual, or other bits of Linux standards.
{-# LANGUAGE DeriveDataTypeable, FlexibleInstances, OverloadedStrings #-}
module Debian.Policy
    ( -- * Paths
      databaseDirectory
    , dataDirectory
    , apacheLogDirectory
    , apacheErrorLog
    , apacheAccessLog
    , serverLogDirectory
    , serverAppLog
    , serverAccessLog
    , errorLogBaseName
    , appLogBaseName
    , accessLogBaseName
    -- * Installed packages
    , debianPackageVersion
    , getDebhelperCompatLevel
    , StandardsVersion(..)
    , getDebianStandardsVersion
    , parseStandardsVersion
    -- * Package fields
    , SourceFormat(..)
    , readSourceFormat
    , PackagePriority(..)
    , readPriority
    , PackageArchitectures(..)
    , parsePackageArchitectures
    , Section(..)
    , readSection
    , MultiArch(..)
    , readMultiArch
    , Area(..)
    , parseUploaders
    , parseMaintainer
    , maintainerOfLastResort
    , getCurrentDebianUser
    , haskellMaintainer
    , License(..)
    , fromCabalLicense
    , toCabalLicense
    , readLicense
    ) where

import Codec.Binary.UTF8.String (decodeString)
import Control.Arrow (second)
import Control.Monad (mplus)
import Data.Char (isSpace, toLower)
import Data.Generics (Data, Typeable)
import Data.List (groupBy, intercalate)
import Data.Maybe (fromMaybe, mapMaybe)
import Data.Text (pack, strip, Text, unpack)
import Debian.Debianize.Prelude (read')
import Debian.Pretty (PP(..))
import Debian.Relation (BinPkgName)
import Debian.Version (DebianVersion, parseDebianVersion', version)
import qualified Distribution.License as Cabal (License(..))
import Distribution.Package (PackageIdentifier(pkgName))
import Distribution.PackageDescription (PackageDescription(package))
import Distribution.Text (display)
import System.Environment (getEnvironment)
import System.FilePath ((</>))
import System.Process (readProcess)
import Text.Parsec (parse)
import Text.Parsec.Rfc2822 (address, NameAddr(..))
import Text.PrettyPrint.HughesPJClass (text)
import Distribution.Pretty (Pretty(pretty))
import Text.Read (readMaybe)

databaseDirectory :: BinPkgName -> String
databaseDirectory :: BinPkgName -> [Char]
databaseDirectory BinPkgName
x = [Char]
"/srv" [Char] -> [Char] -> [Char]
</> Doc -> [Char]
forall a. Show a => a -> [Char]
show (PP BinPkgName -> Doc
forall a. Pretty a => a -> Doc
pretty (PP BinPkgName -> Doc)
-> (BinPkgName -> PP BinPkgName) -> BinPkgName -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> PP BinPkgName
forall a. a -> PP a
PP (BinPkgName -> Doc) -> BinPkgName -> Doc
forall a b. (a -> b) -> a -> b
$ BinPkgName
x)

dataDirectory :: PackageDescription -> String
dataDirectory :: PackageDescription -> [Char]
dataDirectory PackageDescription
pkgDesc = [Char]
"/usr/share" [Char] -> [Char] -> [Char]
</> PackageName -> [Char]
showPkgName (PackageIdentifier -> PackageName
pkgName (PackageDescription -> PackageIdentifier
package PackageDescription
pkgDesc))
    where
      -- Copied from Distribution.Simple.Build.PatsModule in Cabal
      showPkgName :: PackageName -> [Char]
showPkgName = (Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
fixchar ([Char] -> [Char])
-> (PackageName -> [Char]) -> PackageName -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageName -> [Char]
forall a. Pretty a => a -> [Char]
display
      fixchar :: Char -> Char
fixchar Char
'-' = Char
'_'
      fixchar Char
c   = Char
c

apacheLogDirectory :: BinPkgName -> String
apacheLogDirectory :: BinPkgName -> [Char]
apacheLogDirectory BinPkgName
x =  [Char]
"/var/log/apache2/" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Doc -> [Char]
forall a. Show a => a -> [Char]
show (PP BinPkgName -> Doc
forall a. Pretty a => a -> Doc
pretty (PP BinPkgName -> Doc)
-> (BinPkgName -> PP BinPkgName) -> BinPkgName -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> PP BinPkgName
forall a. a -> PP a
PP (BinPkgName -> Doc) -> BinPkgName -> Doc
forall a b. (a -> b) -> a -> b
$ BinPkgName
x)

apacheErrorLog :: BinPkgName -> String
apacheErrorLog :: BinPkgName -> [Char]
apacheErrorLog BinPkgName
x = BinPkgName -> [Char]
apacheLogDirectory BinPkgName
x [Char] -> [Char] -> [Char]
</> [Char]
errorLogBaseName

apacheAccessLog :: BinPkgName -> String
apacheAccessLog :: BinPkgName -> [Char]
apacheAccessLog BinPkgName
x = BinPkgName -> [Char]
apacheLogDirectory BinPkgName
x [Char] -> [Char] -> [Char]
</> [Char]
accessLogBaseName

serverLogDirectory :: BinPkgName -> String
serverLogDirectory :: BinPkgName -> [Char]
serverLogDirectory BinPkgName
x = [Char]
"/var/log/" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Doc -> [Char]
forall a. Show a => a -> [Char]
show (PP BinPkgName -> Doc
forall a. Pretty a => a -> Doc
pretty (PP BinPkgName -> Doc)
-> (BinPkgName -> PP BinPkgName) -> BinPkgName -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinPkgName -> PP BinPkgName
forall a. a -> PP a
PP (BinPkgName -> Doc) -> BinPkgName -> Doc
forall a b. (a -> b) -> a -> b
$ BinPkgName
x)

serverAppLog :: BinPkgName -> String
serverAppLog :: BinPkgName -> [Char]
serverAppLog BinPkgName
x = BinPkgName -> [Char]
serverLogDirectory BinPkgName
x [Char] -> [Char] -> [Char]
</> [Char]
appLogBaseName

serverAccessLog :: BinPkgName -> String
serverAccessLog :: BinPkgName -> [Char]
serverAccessLog BinPkgName
x = BinPkgName -> [Char]
serverLogDirectory BinPkgName
x [Char] -> [Char] -> [Char]
</> [Char]
accessLogBaseName

appLogBaseName :: String
appLogBaseName :: [Char]
appLogBaseName = [Char]
"app.log"

errorLogBaseName :: String
errorLogBaseName :: [Char]
errorLogBaseName = [Char]
"error.log"

accessLogBaseName :: String
accessLogBaseName :: [Char]
accessLogBaseName = [Char]
"access.log"

debianPackageVersion :: String -> IO (Maybe DebianVersion)
debianPackageVersion :: [Char] -> IO (Maybe DebianVersion)
debianPackageVersion [Char]
name =
    [Char] -> [[Char]] -> [Char] -> IO [Char]
readProcess [Char]
"dpkg-query" [[Char]
"--show", [Char]
"--showformat=${version}", [Char]
name] [Char]
"" IO [Char]
-> ([Char] -> IO (Maybe DebianVersion)) -> IO (Maybe DebianVersion)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
    Maybe DebianVersion -> IO (Maybe DebianVersion)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe DebianVersion -> IO (Maybe DebianVersion))
-> ([Char] -> Maybe DebianVersion)
-> [Char]
-> IO (Maybe DebianVersion)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Maybe DebianVersion
forall {string}.
(Eq string, IsString string, ParseDebianVersion string) =>
string -> Maybe DebianVersion
parseDebianVersion''
    where
      -- This should maybe be the real parseDebianVersion
      parseDebianVersion'' :: string -> Maybe DebianVersion
parseDebianVersion'' string
"" = Maybe DebianVersion
forall a. Maybe a
Nothing
      parseDebianVersion'' string
s = DebianVersion -> Maybe DebianVersion
forall a. a -> Maybe a
Just (string -> DebianVersion
forall string. ParseDebianVersion string => string -> DebianVersion
parseDebianVersion' string
s)

-- | With the current state of CDBS, anything above 10 breaks, so
-- for now we force this to 10.
getDebhelperCompatLevel :: IO (Maybe Int)
getDebhelperCompatLevel :: IO (Maybe Int)
getDebhelperCompatLevel = Maybe Int -> IO (Maybe Int)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
10)

data StandardsVersion = StandardsVersion Int Int Int (Maybe Int) deriving (StandardsVersion -> StandardsVersion -> Bool
(StandardsVersion -> StandardsVersion -> Bool)
-> (StandardsVersion -> StandardsVersion -> Bool)
-> Eq StandardsVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StandardsVersion -> StandardsVersion -> Bool
== :: StandardsVersion -> StandardsVersion -> Bool
$c/= :: StandardsVersion -> StandardsVersion -> Bool
/= :: StandardsVersion -> StandardsVersion -> Bool
Eq, Eq StandardsVersion
Eq StandardsVersion =>
(StandardsVersion -> StandardsVersion -> Ordering)
-> (StandardsVersion -> StandardsVersion -> Bool)
-> (StandardsVersion -> StandardsVersion -> Bool)
-> (StandardsVersion -> StandardsVersion -> Bool)
-> (StandardsVersion -> StandardsVersion -> Bool)
-> (StandardsVersion -> StandardsVersion -> StandardsVersion)
-> (StandardsVersion -> StandardsVersion -> StandardsVersion)
-> Ord StandardsVersion
StandardsVersion -> StandardsVersion -> Bool
StandardsVersion -> StandardsVersion -> Ordering
StandardsVersion -> StandardsVersion -> StandardsVersion
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StandardsVersion -> StandardsVersion -> Ordering
compare :: StandardsVersion -> StandardsVersion -> Ordering
$c< :: StandardsVersion -> StandardsVersion -> Bool
< :: StandardsVersion -> StandardsVersion -> Bool
$c<= :: StandardsVersion -> StandardsVersion -> Bool
<= :: StandardsVersion -> StandardsVersion -> Bool
$c> :: StandardsVersion -> StandardsVersion -> Bool
> :: StandardsVersion -> StandardsVersion -> Bool
$c>= :: StandardsVersion -> StandardsVersion -> Bool
>= :: StandardsVersion -> StandardsVersion -> Bool
$cmax :: StandardsVersion -> StandardsVersion -> StandardsVersion
max :: StandardsVersion -> StandardsVersion -> StandardsVersion
$cmin :: StandardsVersion -> StandardsVersion -> StandardsVersion
min :: StandardsVersion -> StandardsVersion -> StandardsVersion
Ord, Int -> StandardsVersion -> [Char] -> [Char]
[StandardsVersion] -> [Char] -> [Char]
StandardsVersion -> [Char]
(Int -> StandardsVersion -> [Char] -> [Char])
-> (StandardsVersion -> [Char])
-> ([StandardsVersion] -> [Char] -> [Char])
-> Show StandardsVersion
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
$cshowsPrec :: Int -> StandardsVersion -> [Char] -> [Char]
showsPrec :: Int -> StandardsVersion -> [Char] -> [Char]
$cshow :: StandardsVersion -> [Char]
show :: StandardsVersion -> [Char]
$cshowList :: [StandardsVersion] -> [Char] -> [Char]
showList :: [StandardsVersion] -> [Char] -> [Char]
Show, Typeable StandardsVersion
Typeable StandardsVersion =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> StandardsVersion -> c StandardsVersion)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StandardsVersion)
-> (StandardsVersion -> Constr)
-> (StandardsVersion -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StandardsVersion))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c StandardsVersion))
-> ((forall b. Data b => b -> b)
    -> StandardsVersion -> StandardsVersion)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StandardsVersion -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StandardsVersion -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> StandardsVersion -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StandardsVersion -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> StandardsVersion -> m StandardsVersion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StandardsVersion -> m StandardsVersion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StandardsVersion -> m StandardsVersion)
-> Data StandardsVersion
StandardsVersion -> Constr
StandardsVersion -> DataType
(forall b. Data b => b -> b)
-> StandardsVersion -> StandardsVersion
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> StandardsVersion -> u
forall u. (forall d. Data d => d -> u) -> StandardsVersion -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StandardsVersion -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StandardsVersion -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StandardsVersion -> m StandardsVersion
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandardsVersion -> m StandardsVersion
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StandardsVersion
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StandardsVersion -> c StandardsVersion
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StandardsVersion)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StandardsVersion)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StandardsVersion -> c StandardsVersion
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StandardsVersion -> c StandardsVersion
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StandardsVersion
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StandardsVersion
$ctoConstr :: StandardsVersion -> Constr
toConstr :: StandardsVersion -> Constr
$cdataTypeOf :: StandardsVersion -> DataType
dataTypeOf :: StandardsVersion -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StandardsVersion)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StandardsVersion)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StandardsVersion)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StandardsVersion)
$cgmapT :: (forall b. Data b => b -> b)
-> StandardsVersion -> StandardsVersion
gmapT :: (forall b. Data b => b -> b)
-> StandardsVersion -> StandardsVersion
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StandardsVersion -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StandardsVersion -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StandardsVersion -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StandardsVersion -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> StandardsVersion -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> StandardsVersion -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StandardsVersion -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StandardsVersion -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StandardsVersion -> m StandardsVersion
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StandardsVersion -> m StandardsVersion
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandardsVersion -> m StandardsVersion
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandardsVersion -> m StandardsVersion
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandardsVersion -> m StandardsVersion
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StandardsVersion -> m StandardsVersion
Data, Typeable)

instance Pretty (PP StandardsVersion) where
    pretty :: PP StandardsVersion -> Doc
pretty (PP (StandardsVersion Int
a Int
b Int
c (Just Int
d))) = [Char] -> Doc
text (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
a) Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
text [Char]
"." Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
text (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
b) Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
text [Char]
"." Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
text (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
c) Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
text [Char]
"." Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
text (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
d)
    pretty (PP (StandardsVersion Int
a Int
b Int
c Maybe Int
Nothing)) = [Char] -> Doc
text (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
a) Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
text [Char]
"." Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
text (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
b) Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
text [Char]
"." Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
text (Int -> [Char]
forall a. Show a => a -> [Char]
show Int
c)

-- | Assumes debian-policy is installed
getDebianStandardsVersion :: IO (Maybe StandardsVersion)
getDebianStandardsVersion :: IO (Maybe StandardsVersion)
getDebianStandardsVersion = [Char] -> IO (Maybe DebianVersion)
debianPackageVersion [Char]
"debian-policy" IO (Maybe DebianVersion)
-> (Maybe DebianVersion -> IO (Maybe StandardsVersion))
-> IO (Maybe StandardsVersion)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Maybe StandardsVersion -> IO (Maybe StandardsVersion)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe StandardsVersion -> IO (Maybe StandardsVersion))
-> (Maybe DebianVersion -> Maybe StandardsVersion)
-> Maybe DebianVersion
-> IO (Maybe StandardsVersion)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DebianVersion -> StandardsVersion)
-> Maybe DebianVersion -> Maybe StandardsVersion
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Char] -> StandardsVersion
parseStandardsVersion ([Char] -> StandardsVersion)
-> (DebianVersion -> [Char]) -> DebianVersion -> StandardsVersion
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DebianVersion -> [Char]
version)

parseStandardsVersion :: String -> StandardsVersion
parseStandardsVersion :: [Char] -> StandardsVersion
parseStandardsVersion [Char]
s =
    case ([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
filter ([Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
/= [Char]
".") ((Char -> Char -> Bool) -> [Char] -> [[Char]]
forall a. (a -> a -> Bool) -> [a] -> [[a]]
groupBy (\ Char
a Char
b -> (Char
a Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'.') Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== (Char
b Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'.')) [Char]
s) of
      ([Char]
a : [Char]
b : [Char]
c : [Char]
d : [[Char]]
_) -> Int -> Int -> Int -> Maybe Int -> StandardsVersion
StandardsVersion (([Char] -> Int) -> [Char] -> Int
forall a. Read a => ([Char] -> a) -> [Char] -> a
read' ([Char] -> Int
forall a. HasCallStack => [Char] -> a
error ([Char] -> Int) -> ([Char] -> [Char]) -> [Char] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
"StandardsVersion" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char]
forall a. Show a => a -> [Char]
show) [Char]
a)
                                              (([Char] -> Int) -> [Char] -> Int
forall a. Read a => ([Char] -> a) -> [Char] -> a
read' ([Char] -> Int
forall a. HasCallStack => [Char] -> a
error ([Char] -> Int) -> ([Char] -> [Char]) -> [Char] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
"StandardsVersion" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char]
forall a. Show a => a -> [Char]
show) [Char]
b)
                                              (([Char] -> Int) -> [Char] -> Int
forall a. Read a => ([Char] -> a) -> [Char] -> a
read' ([Char] -> Int
forall a. HasCallStack => [Char] -> a
error ([Char] -> Int) -> ([Char] -> [Char]) -> [Char] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
"StandardsVersion" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char]
forall a. Show a => a -> [Char]
show) [Char]
c)
                                              (Int -> Maybe Int
forall a. a -> Maybe a
Just (([Char] -> Int) -> [Char] -> Int
forall a. Read a => ([Char] -> a) -> [Char] -> a
read' ([Char] -> Int
forall a. HasCallStack => [Char] -> a
error ([Char] -> Int) -> ([Char] -> [Char]) -> [Char] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
"StandardsVersion" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char]
forall a. Show a => a -> [Char]
show) [Char]
d))
      ([Char]
a : [Char]
b : [Char]
c : [[Char]]
_) -> Int -> Int -> Int -> Maybe Int -> StandardsVersion
StandardsVersion (([Char] -> Int) -> [Char] -> Int
forall a. Read a => ([Char] -> a) -> [Char] -> a
read' ([Char] -> Int
forall a. HasCallStack => [Char] -> a
error ([Char] -> Int) -> ([Char] -> [Char]) -> [Char] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
"StandardsVersion" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char]
forall a. Show a => a -> [Char]
show) [Char]
a)
                                          (([Char] -> Int) -> [Char] -> Int
forall a. Read a => ([Char] -> a) -> [Char] -> a
read' ([Char] -> Int
forall a. HasCallStack => [Char] -> a
error ([Char] -> Int) -> ([Char] -> [Char]) -> [Char] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
"StandardsVersion" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char]
forall a. Show a => a -> [Char]
show) [Char]
b)
                                          (([Char] -> Int) -> [Char] -> Int
forall a. Read a => ([Char] -> a) -> [Char] -> a
read' ([Char] -> Int
forall a. HasCallStack => [Char] -> a
error ([Char] -> Int) -> ([Char] -> [Char]) -> [Char] -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
"StandardsVersion" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char]
forall a. Show a => a -> [Char]
show) [Char]
c) Maybe Int
forall a. Maybe a
Nothing
      [[Char]]
_ -> [Char] -> StandardsVersion
forall a. HasCallStack => [Char] -> a
error ([Char] -> StandardsVersion) -> [Char] -> StandardsVersion
forall a b. (a -> b) -> a -> b
$ [Char]
"Invalid Standards-Version string: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
s

data SourceFormat
    = Native3
    | Quilt3
    deriving (SourceFormat -> SourceFormat -> Bool
(SourceFormat -> SourceFormat -> Bool)
-> (SourceFormat -> SourceFormat -> Bool) -> Eq SourceFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SourceFormat -> SourceFormat -> Bool
== :: SourceFormat -> SourceFormat -> Bool
$c/= :: SourceFormat -> SourceFormat -> Bool
/= :: SourceFormat -> SourceFormat -> Bool
Eq, Eq SourceFormat
Eq SourceFormat =>
(SourceFormat -> SourceFormat -> Ordering)
-> (SourceFormat -> SourceFormat -> Bool)
-> (SourceFormat -> SourceFormat -> Bool)
-> (SourceFormat -> SourceFormat -> Bool)
-> (SourceFormat -> SourceFormat -> Bool)
-> (SourceFormat -> SourceFormat -> SourceFormat)
-> (SourceFormat -> SourceFormat -> SourceFormat)
-> Ord SourceFormat
SourceFormat -> SourceFormat -> Bool
SourceFormat -> SourceFormat -> Ordering
SourceFormat -> SourceFormat -> SourceFormat
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SourceFormat -> SourceFormat -> Ordering
compare :: SourceFormat -> SourceFormat -> Ordering
$c< :: SourceFormat -> SourceFormat -> Bool
< :: SourceFormat -> SourceFormat -> Bool
$c<= :: SourceFormat -> SourceFormat -> Bool
<= :: SourceFormat -> SourceFormat -> Bool
$c> :: SourceFormat -> SourceFormat -> Bool
> :: SourceFormat -> SourceFormat -> Bool
$c>= :: SourceFormat -> SourceFormat -> Bool
>= :: SourceFormat -> SourceFormat -> Bool
$cmax :: SourceFormat -> SourceFormat -> SourceFormat
max :: SourceFormat -> SourceFormat -> SourceFormat
$cmin :: SourceFormat -> SourceFormat -> SourceFormat
min :: SourceFormat -> SourceFormat -> SourceFormat
Ord, Int -> SourceFormat -> [Char] -> [Char]
[SourceFormat] -> [Char] -> [Char]
SourceFormat -> [Char]
(Int -> SourceFormat -> [Char] -> [Char])
-> (SourceFormat -> [Char])
-> ([SourceFormat] -> [Char] -> [Char])
-> Show SourceFormat
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
$cshowsPrec :: Int -> SourceFormat -> [Char] -> [Char]
showsPrec :: Int -> SourceFormat -> [Char] -> [Char]
$cshow :: SourceFormat -> [Char]
show :: SourceFormat -> [Char]
$cshowList :: [SourceFormat] -> [Char] -> [Char]
showList :: [SourceFormat] -> [Char] -> [Char]
Show, Typeable SourceFormat
Typeable SourceFormat =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SourceFormat -> c SourceFormat)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SourceFormat)
-> (SourceFormat -> Constr)
-> (SourceFormat -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SourceFormat))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SourceFormat))
-> ((forall b. Data b => b -> b) -> SourceFormat -> SourceFormat)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceFormat -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceFormat -> r)
-> (forall u. (forall d. Data d => d -> u) -> SourceFormat -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SourceFormat -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SourceFormat -> m SourceFormat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SourceFormat -> m SourceFormat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SourceFormat -> m SourceFormat)
-> Data SourceFormat
SourceFormat -> Constr
SourceFormat -> DataType
(forall b. Data b => b -> b) -> SourceFormat -> SourceFormat
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SourceFormat -> u
forall u. (forall d. Data d => d -> u) -> SourceFormat -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceFormat -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceFormat -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourceFormat -> m SourceFormat
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceFormat -> m SourceFormat
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceFormat
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceFormat -> c SourceFormat
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceFormat)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceFormat)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceFormat -> c SourceFormat
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceFormat -> c SourceFormat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceFormat
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceFormat
$ctoConstr :: SourceFormat -> Constr
toConstr :: SourceFormat -> Constr
$cdataTypeOf :: SourceFormat -> DataType
dataTypeOf :: SourceFormat -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceFormat)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceFormat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceFormat)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceFormat)
$cgmapT :: (forall b. Data b => b -> b) -> SourceFormat -> SourceFormat
gmapT :: (forall b. Data b => b -> b) -> SourceFormat -> SourceFormat
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceFormat -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceFormat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceFormat -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceFormat -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SourceFormat -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SourceFormat -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SourceFormat -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SourceFormat -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourceFormat -> m SourceFormat
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourceFormat -> m SourceFormat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceFormat -> m SourceFormat
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceFormat -> m SourceFormat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceFormat -> m SourceFormat
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceFormat -> m SourceFormat
Data, Typeable)

instance Pretty (PP SourceFormat) where
    pretty :: PP SourceFormat -> Doc
pretty (PP SourceFormat
Quilt3) = [Char] -> Doc
text [Char]
"3.0 (quilt)\n"
    pretty (PP SourceFormat
Native3) = [Char] -> Doc
text [Char]
"3.0 (native)\n"

readSourceFormat :: Text -> Either Text SourceFormat
readSourceFormat :: Text -> Either Text SourceFormat
readSourceFormat Text
s =
    case () of
      ()
_ | Text -> Text
strip Text
s Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"3.0 (native)" -> SourceFormat -> Either Text SourceFormat
forall a b. b -> Either a b
Right SourceFormat
Native3
      ()
_ | Text -> Text
strip Text
s Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"3.0 (quilt)" -> SourceFormat -> Either Text SourceFormat
forall a b. b -> Either a b
Right SourceFormat
Quilt3
      ()
_ -> Text -> Either Text SourceFormat
forall a b. a -> Either a b
Left (Text -> Either Text SourceFormat)
-> Text -> Either Text SourceFormat
forall a b. (a -> b) -> a -> b
$ Text
"Invalid debian/source/format: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
pack (Text -> [Char]
forall a. Show a => a -> [Char]
show (Text -> Text
strip Text
s))

data PackagePriority
    = Required
    | Important
    | Standard
    | Optional
    | Extra
    deriving (PackagePriority -> PackagePriority -> Bool
(PackagePriority -> PackagePriority -> Bool)
-> (PackagePriority -> PackagePriority -> Bool)
-> Eq PackagePriority
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PackagePriority -> PackagePriority -> Bool
== :: PackagePriority -> PackagePriority -> Bool
$c/= :: PackagePriority -> PackagePriority -> Bool
/= :: PackagePriority -> PackagePriority -> Bool
Eq, Eq PackagePriority
Eq PackagePriority =>
(PackagePriority -> PackagePriority -> Ordering)
-> (PackagePriority -> PackagePriority -> Bool)
-> (PackagePriority -> PackagePriority -> Bool)
-> (PackagePriority -> PackagePriority -> Bool)
-> (PackagePriority -> PackagePriority -> Bool)
-> (PackagePriority -> PackagePriority -> PackagePriority)
-> (PackagePriority -> PackagePriority -> PackagePriority)
-> Ord PackagePriority
PackagePriority -> PackagePriority -> Bool
PackagePriority -> PackagePriority -> Ordering
PackagePriority -> PackagePriority -> PackagePriority
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PackagePriority -> PackagePriority -> Ordering
compare :: PackagePriority -> PackagePriority -> Ordering
$c< :: PackagePriority -> PackagePriority -> Bool
< :: PackagePriority -> PackagePriority -> Bool
$c<= :: PackagePriority -> PackagePriority -> Bool
<= :: PackagePriority -> PackagePriority -> Bool
$c> :: PackagePriority -> PackagePriority -> Bool
> :: PackagePriority -> PackagePriority -> Bool
$c>= :: PackagePriority -> PackagePriority -> Bool
>= :: PackagePriority -> PackagePriority -> Bool
$cmax :: PackagePriority -> PackagePriority -> PackagePriority
max :: PackagePriority -> PackagePriority -> PackagePriority
$cmin :: PackagePriority -> PackagePriority -> PackagePriority
min :: PackagePriority -> PackagePriority -> PackagePriority
Ord, ReadPrec [PackagePriority]
ReadPrec PackagePriority
Int -> ReadS PackagePriority
ReadS [PackagePriority]
(Int -> ReadS PackagePriority)
-> ReadS [PackagePriority]
-> ReadPrec PackagePriority
-> ReadPrec [PackagePriority]
-> Read PackagePriority
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PackagePriority
readsPrec :: Int -> ReadS PackagePriority
$creadList :: ReadS [PackagePriority]
readList :: ReadS [PackagePriority]
$creadPrec :: ReadPrec PackagePriority
readPrec :: ReadPrec PackagePriority
$creadListPrec :: ReadPrec [PackagePriority]
readListPrec :: ReadPrec [PackagePriority]
Read, Int -> PackagePriority -> [Char] -> [Char]
[PackagePriority] -> [Char] -> [Char]
PackagePriority -> [Char]
(Int -> PackagePriority -> [Char] -> [Char])
-> (PackagePriority -> [Char])
-> ([PackagePriority] -> [Char] -> [Char])
-> Show PackagePriority
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
$cshowsPrec :: Int -> PackagePriority -> [Char] -> [Char]
showsPrec :: Int -> PackagePriority -> [Char] -> [Char]
$cshow :: PackagePriority -> [Char]
show :: PackagePriority -> [Char]
$cshowList :: [PackagePriority] -> [Char] -> [Char]
showList :: [PackagePriority] -> [Char] -> [Char]
Show, Typeable PackagePriority
Typeable PackagePriority =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PackagePriority -> c PackagePriority)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PackagePriority)
-> (PackagePriority -> Constr)
-> (PackagePriority -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PackagePriority))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PackagePriority))
-> ((forall b. Data b => b -> b)
    -> PackagePriority -> PackagePriority)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PackagePriority -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PackagePriority -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PackagePriority -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PackagePriority -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PackagePriority -> m PackagePriority)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PackagePriority -> m PackagePriority)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PackagePriority -> m PackagePriority)
-> Data PackagePriority
PackagePriority -> Constr
PackagePriority -> DataType
(forall b. Data b => b -> b) -> PackagePriority -> PackagePriority
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> PackagePriority -> u
forall u. (forall d. Data d => d -> u) -> PackagePriority -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackagePriority -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackagePriority -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PackagePriority -> m PackagePriority
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackagePriority -> m PackagePriority
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PackagePriority
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PackagePriority -> c PackagePriority
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PackagePriority)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PackagePriority)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PackagePriority -> c PackagePriority
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PackagePriority -> c PackagePriority
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PackagePriority
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PackagePriority
$ctoConstr :: PackagePriority -> Constr
toConstr :: PackagePriority -> Constr
$cdataTypeOf :: PackagePriority -> DataType
dataTypeOf :: PackagePriority -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PackagePriority)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PackagePriority)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PackagePriority)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PackagePriority)
$cgmapT :: (forall b. Data b => b -> b) -> PackagePriority -> PackagePriority
gmapT :: (forall b. Data b => b -> b) -> PackagePriority -> PackagePriority
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackagePriority -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackagePriority -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackagePriority -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackagePriority -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PackagePriority -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PackagePriority -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PackagePriority -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PackagePriority -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PackagePriority -> m PackagePriority
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PackagePriority -> m PackagePriority
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackagePriority -> m PackagePriority
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackagePriority -> m PackagePriority
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackagePriority -> m PackagePriority
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackagePriority -> m PackagePriority
Data, Typeable)

readPriority :: String -> PackagePriority
readPriority :: [Char] -> PackagePriority
readPriority [Char]
s =
    case Text -> [Char]
unpack (Text -> Text
strip ([Char] -> Text
pack [Char]
s)) of
      [Char]
"required" -> PackagePriority
Required
      [Char]
"important" -> PackagePriority
Important
      [Char]
"standard" -> PackagePriority
Standard
      [Char]
"optional" -> PackagePriority
Optional
      [Char]
"extra" -> PackagePriority
Extra
      [Char]
x -> [Char] -> PackagePriority
forall a. HasCallStack => [Char] -> a
error ([Char] -> PackagePriority) -> [Char] -> PackagePriority
forall a b. (a -> b) -> a -> b
$ [Char]
"Invalid priority string: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
x

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

-- | The architectures for which a binary deb can be built.
data PackageArchitectures
    = All            -- ^ The package is architecture independenct
    | Any            -- ^ The package can be built for any architecture
    | Names [String] -- ^ The list of suitable architectures
    deriving (ReadPrec [PackageArchitectures]
ReadPrec PackageArchitectures
Int -> ReadS PackageArchitectures
ReadS [PackageArchitectures]
(Int -> ReadS PackageArchitectures)
-> ReadS [PackageArchitectures]
-> ReadPrec PackageArchitectures
-> ReadPrec [PackageArchitectures]
-> Read PackageArchitectures
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PackageArchitectures
readsPrec :: Int -> ReadS PackageArchitectures
$creadList :: ReadS [PackageArchitectures]
readList :: ReadS [PackageArchitectures]
$creadPrec :: ReadPrec PackageArchitectures
readPrec :: ReadPrec PackageArchitectures
$creadListPrec :: ReadPrec [PackageArchitectures]
readListPrec :: ReadPrec [PackageArchitectures]
Read, PackageArchitectures -> PackageArchitectures -> Bool
(PackageArchitectures -> PackageArchitectures -> Bool)
-> (PackageArchitectures -> PackageArchitectures -> Bool)
-> Eq PackageArchitectures
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PackageArchitectures -> PackageArchitectures -> Bool
== :: PackageArchitectures -> PackageArchitectures -> Bool
$c/= :: PackageArchitectures -> PackageArchitectures -> Bool
/= :: PackageArchitectures -> PackageArchitectures -> Bool
Eq, Eq PackageArchitectures
Eq PackageArchitectures =>
(PackageArchitectures -> PackageArchitectures -> Ordering)
-> (PackageArchitectures -> PackageArchitectures -> Bool)
-> (PackageArchitectures -> PackageArchitectures -> Bool)
-> (PackageArchitectures -> PackageArchitectures -> Bool)
-> (PackageArchitectures -> PackageArchitectures -> Bool)
-> (PackageArchitectures
    -> PackageArchitectures -> PackageArchitectures)
-> (PackageArchitectures
    -> PackageArchitectures -> PackageArchitectures)
-> Ord PackageArchitectures
PackageArchitectures -> PackageArchitectures -> Bool
PackageArchitectures -> PackageArchitectures -> Ordering
PackageArchitectures
-> PackageArchitectures -> PackageArchitectures
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PackageArchitectures -> PackageArchitectures -> Ordering
compare :: PackageArchitectures -> PackageArchitectures -> Ordering
$c< :: PackageArchitectures -> PackageArchitectures -> Bool
< :: PackageArchitectures -> PackageArchitectures -> Bool
$c<= :: PackageArchitectures -> PackageArchitectures -> Bool
<= :: PackageArchitectures -> PackageArchitectures -> Bool
$c> :: PackageArchitectures -> PackageArchitectures -> Bool
> :: PackageArchitectures -> PackageArchitectures -> Bool
$c>= :: PackageArchitectures -> PackageArchitectures -> Bool
>= :: PackageArchitectures -> PackageArchitectures -> Bool
$cmax :: PackageArchitectures
-> PackageArchitectures -> PackageArchitectures
max :: PackageArchitectures
-> PackageArchitectures -> PackageArchitectures
$cmin :: PackageArchitectures
-> PackageArchitectures -> PackageArchitectures
min :: PackageArchitectures
-> PackageArchitectures -> PackageArchitectures
Ord, Int -> PackageArchitectures -> [Char] -> [Char]
[PackageArchitectures] -> [Char] -> [Char]
PackageArchitectures -> [Char]
(Int -> PackageArchitectures -> [Char] -> [Char])
-> (PackageArchitectures -> [Char])
-> ([PackageArchitectures] -> [Char] -> [Char])
-> Show PackageArchitectures
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
$cshowsPrec :: Int -> PackageArchitectures -> [Char] -> [Char]
showsPrec :: Int -> PackageArchitectures -> [Char] -> [Char]
$cshow :: PackageArchitectures -> [Char]
show :: PackageArchitectures -> [Char]
$cshowList :: [PackageArchitectures] -> [Char] -> [Char]
showList :: [PackageArchitectures] -> [Char] -> [Char]
Show, Typeable PackageArchitectures
Typeable PackageArchitectures =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> PackageArchitectures
 -> c PackageArchitectures)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PackageArchitectures)
-> (PackageArchitectures -> Constr)
-> (PackageArchitectures -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PackageArchitectures))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PackageArchitectures))
-> ((forall b. Data b => b -> b)
    -> PackageArchitectures -> PackageArchitectures)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PackageArchitectures -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PackageArchitectures -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PackageArchitectures -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PackageArchitectures -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PackageArchitectures -> m PackageArchitectures)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PackageArchitectures -> m PackageArchitectures)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PackageArchitectures -> m PackageArchitectures)
-> Data PackageArchitectures
PackageArchitectures -> Constr
PackageArchitectures -> DataType
(forall b. Data b => b -> b)
-> PackageArchitectures -> PackageArchitectures
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> PackageArchitectures -> u
forall u.
(forall d. Data d => d -> u) -> PackageArchitectures -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackageArchitectures -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackageArchitectures -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PackageArchitectures -> m PackageArchitectures
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackageArchitectures -> m PackageArchitectures
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PackageArchitectures
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PackageArchitectures
-> c PackageArchitectures
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PackageArchitectures)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PackageArchitectures)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PackageArchitectures
-> c PackageArchitectures
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PackageArchitectures
-> c PackageArchitectures
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PackageArchitectures
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PackageArchitectures
$ctoConstr :: PackageArchitectures -> Constr
toConstr :: PackageArchitectures -> Constr
$cdataTypeOf :: PackageArchitectures -> DataType
dataTypeOf :: PackageArchitectures -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PackageArchitectures)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PackageArchitectures)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PackageArchitectures)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PackageArchitectures)
$cgmapT :: (forall b. Data b => b -> b)
-> PackageArchitectures -> PackageArchitectures
gmapT :: (forall b. Data b => b -> b)
-> PackageArchitectures -> PackageArchitectures
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackageArchitectures -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackageArchitectures -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackageArchitectures -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackageArchitectures -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> PackageArchitectures -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> PackageArchitectures -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PackageArchitectures -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PackageArchitectures -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PackageArchitectures -> m PackageArchitectures
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PackageArchitectures -> m PackageArchitectures
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackageArchitectures -> m PackageArchitectures
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackageArchitectures -> m PackageArchitectures
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackageArchitectures -> m PackageArchitectures
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PackageArchitectures -> m PackageArchitectures
Data, Typeable)

instance Pretty (PP PackageArchitectures) where
    pretty :: PP PackageArchitectures -> Doc
pretty (PP PackageArchitectures
All) = [Char] -> Doc
text [Char]
"all"
    pretty (PP PackageArchitectures
Any) = [Char] -> Doc
text [Char]
"any"
    pretty (PP (Names [[Char]]
xs)) = [Char] -> Doc
text ([Char] -> Doc) -> [Char] -> Doc
forall a b. (a -> b) -> a -> b
$ [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
" " [[Char]]
xs

parsePackageArchitectures :: String -> PackageArchitectures
parsePackageArchitectures :: [Char] -> PackageArchitectures
parsePackageArchitectures [Char]
"all" = PackageArchitectures
All
parsePackageArchitectures [Char]
"any" = PackageArchitectures
Any
parsePackageArchitectures [Char]
s = [Char] -> PackageArchitectures
forall a. HasCallStack => [Char] -> a
error ([Char] -> PackageArchitectures) -> [Char] -> PackageArchitectures
forall a b. (a -> b) -> a -> b
$ [Char]
"FIXME: parsePackageArchitectures " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
s

data Section
    = MainSection String -- Equivalent to AreaSection Main s?
    | AreaSection Area String
    deriving (ReadPrec [Section]
ReadPrec Section
Int -> ReadS Section
ReadS [Section]
(Int -> ReadS Section)
-> ReadS [Section]
-> ReadPrec Section
-> ReadPrec [Section]
-> Read Section
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Section
readsPrec :: Int -> ReadS Section
$creadList :: ReadS [Section]
readList :: ReadS [Section]
$creadPrec :: ReadPrec Section
readPrec :: ReadPrec Section
$creadListPrec :: ReadPrec [Section]
readListPrec :: ReadPrec [Section]
Read, Section -> Section -> Bool
(Section -> Section -> Bool)
-> (Section -> Section -> Bool) -> Eq Section
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Section -> Section -> Bool
== :: Section -> Section -> Bool
$c/= :: Section -> Section -> Bool
/= :: Section -> Section -> Bool
Eq, Eq Section
Eq Section =>
(Section -> Section -> Ordering)
-> (Section -> Section -> Bool)
-> (Section -> Section -> Bool)
-> (Section -> Section -> Bool)
-> (Section -> Section -> Bool)
-> (Section -> Section -> Section)
-> (Section -> Section -> Section)
-> Ord Section
Section -> Section -> Bool
Section -> Section -> Ordering
Section -> Section -> Section
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Section -> Section -> Ordering
compare :: Section -> Section -> Ordering
$c< :: Section -> Section -> Bool
< :: Section -> Section -> Bool
$c<= :: Section -> Section -> Bool
<= :: Section -> Section -> Bool
$c> :: Section -> Section -> Bool
> :: Section -> Section -> Bool
$c>= :: Section -> Section -> Bool
>= :: Section -> Section -> Bool
$cmax :: Section -> Section -> Section
max :: Section -> Section -> Section
$cmin :: Section -> Section -> Section
min :: Section -> Section -> Section
Ord, Int -> Section -> [Char] -> [Char]
[Section] -> [Char] -> [Char]
Section -> [Char]
(Int -> Section -> [Char] -> [Char])
-> (Section -> [Char])
-> ([Section] -> [Char] -> [Char])
-> Show Section
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
$cshowsPrec :: Int -> Section -> [Char] -> [Char]
showsPrec :: Int -> Section -> [Char] -> [Char]
$cshow :: Section -> [Char]
show :: Section -> [Char]
$cshowList :: [Section] -> [Char] -> [Char]
showList :: [Section] -> [Char] -> [Char]
Show, Typeable Section
Typeable Section =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Section -> c Section)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Section)
-> (Section -> Constr)
-> (Section -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Section))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Section))
-> ((forall b. Data b => b -> b) -> Section -> Section)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Section -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Section -> r)
-> (forall u. (forall d. Data d => d -> u) -> Section -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Section -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Section -> m Section)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Section -> m Section)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Section -> m Section)
-> Data Section
Section -> Constr
Section -> DataType
(forall b. Data b => b -> b) -> Section -> Section
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Section -> u
forall u. (forall d. Data d => d -> u) -> Section -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Section -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Section -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Section -> m Section
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Section -> m Section
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Section
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Section -> c Section
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Section)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Section)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Section -> c Section
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Section -> c Section
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Section
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Section
$ctoConstr :: Section -> Constr
toConstr :: Section -> Constr
$cdataTypeOf :: Section -> DataType
dataTypeOf :: Section -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Section)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Section)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Section)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Section)
$cgmapT :: (forall b. Data b => b -> b) -> Section -> Section
gmapT :: (forall b. Data b => b -> b) -> Section -> Section
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Section -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Section -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Section -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Section -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Section -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Section -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Section -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Section -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Section -> m Section
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Section -> m Section
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Section -> m Section
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Section -> m Section
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Section -> m Section
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Section -> m Section
Data, Typeable)

readSection :: String -> Section
readSection :: [Char] -> Section
readSection [Char]
s =
    case (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'/') [Char]
s of
      ([Char]
"contrib", Char
'/' : [Char]
b) -> Area -> [Char] -> Section
AreaSection Area
Contrib ([Char] -> [Char]
forall a. HasCallStack => [a] -> [a]
tail [Char]
b)
      ([Char]
"non-free", Char
'/' : [Char]
b) -> Area -> [Char] -> Section
AreaSection Area
NonFree ([Char] -> [Char]
forall a. HasCallStack => [a] -> [a]
tail [Char]
b)
      ([Char]
"main", Char
'/' : [Char]
b) -> Area -> [Char] -> Section
AreaSection Area
Main ([Char] -> [Char]
forall a. HasCallStack => [a] -> [a]
tail [Char]
b)
      ([Char]
a, Char
'/' : [Char]
_) -> [Char] -> Section
forall a. HasCallStack => [Char] -> a
error ([Char] -> Section) -> [Char] -> Section
forall a b. (a -> b) -> a -> b
$ [Char]
"readSection - unknown area: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
a
      ([Char]
a, [Char]
_) -> [Char] -> Section
MainSection [Char]
a

instance Pretty (PP Section) where
    pretty :: PP Section -> Doc
pretty (PP (MainSection [Char]
sec)) = [Char] -> Doc
text [Char]
sec
    pretty (PP (AreaSection Area
area [Char]
sec)) = PP Area -> Doc
forall a. Pretty a => a -> Doc
pretty (Area -> PP Area
forall a. a -> PP a
PP Area
area) Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
text [Char]
"/" Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> [Char] -> Doc
text [Char]
sec

data MultiArch = MANo | MASame | MAForeign | MAAllowed
    deriving (ReadPrec [MultiArch]
ReadPrec MultiArch
Int -> ReadS MultiArch
ReadS [MultiArch]
(Int -> ReadS MultiArch)
-> ReadS [MultiArch]
-> ReadPrec MultiArch
-> ReadPrec [MultiArch]
-> Read MultiArch
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MultiArch
readsPrec :: Int -> ReadS MultiArch
$creadList :: ReadS [MultiArch]
readList :: ReadS [MultiArch]
$creadPrec :: ReadPrec MultiArch
readPrec :: ReadPrec MultiArch
$creadListPrec :: ReadPrec [MultiArch]
readListPrec :: ReadPrec [MultiArch]
Read, MultiArch -> MultiArch -> Bool
(MultiArch -> MultiArch -> Bool)
-> (MultiArch -> MultiArch -> Bool) -> Eq MultiArch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MultiArch -> MultiArch -> Bool
== :: MultiArch -> MultiArch -> Bool
$c/= :: MultiArch -> MultiArch -> Bool
/= :: MultiArch -> MultiArch -> Bool
Eq, Eq MultiArch
Eq MultiArch =>
(MultiArch -> MultiArch -> Ordering)
-> (MultiArch -> MultiArch -> Bool)
-> (MultiArch -> MultiArch -> Bool)
-> (MultiArch -> MultiArch -> Bool)
-> (MultiArch -> MultiArch -> Bool)
-> (MultiArch -> MultiArch -> MultiArch)
-> (MultiArch -> MultiArch -> MultiArch)
-> Ord MultiArch
MultiArch -> MultiArch -> Bool
MultiArch -> MultiArch -> Ordering
MultiArch -> MultiArch -> MultiArch
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MultiArch -> MultiArch -> Ordering
compare :: MultiArch -> MultiArch -> Ordering
$c< :: MultiArch -> MultiArch -> Bool
< :: MultiArch -> MultiArch -> Bool
$c<= :: MultiArch -> MultiArch -> Bool
<= :: MultiArch -> MultiArch -> Bool
$c> :: MultiArch -> MultiArch -> Bool
> :: MultiArch -> MultiArch -> Bool
$c>= :: MultiArch -> MultiArch -> Bool
>= :: MultiArch -> MultiArch -> Bool
$cmax :: MultiArch -> MultiArch -> MultiArch
max :: MultiArch -> MultiArch -> MultiArch
$cmin :: MultiArch -> MultiArch -> MultiArch
min :: MultiArch -> MultiArch -> MultiArch
Ord, Int -> MultiArch -> [Char] -> [Char]
[MultiArch] -> [Char] -> [Char]
MultiArch -> [Char]
(Int -> MultiArch -> [Char] -> [Char])
-> (MultiArch -> [Char])
-> ([MultiArch] -> [Char] -> [Char])
-> Show MultiArch
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
$cshowsPrec :: Int -> MultiArch -> [Char] -> [Char]
showsPrec :: Int -> MultiArch -> [Char] -> [Char]
$cshow :: MultiArch -> [Char]
show :: MultiArch -> [Char]
$cshowList :: [MultiArch] -> [Char] -> [Char]
showList :: [MultiArch] -> [Char] -> [Char]
Show, Typeable MultiArch
Typeable MultiArch =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MultiArch -> c MultiArch)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MultiArch)
-> (MultiArch -> Constr)
-> (MultiArch -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MultiArch))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MultiArch))
-> ((forall b. Data b => b -> b) -> MultiArch -> MultiArch)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MultiArch -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MultiArch -> r)
-> (forall u. (forall d. Data d => d -> u) -> MultiArch -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MultiArch -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MultiArch -> m MultiArch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MultiArch -> m MultiArch)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MultiArch -> m MultiArch)
-> Data MultiArch
MultiArch -> Constr
MultiArch -> DataType
(forall b. Data b => b -> b) -> MultiArch -> MultiArch
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MultiArch -> u
forall u. (forall d. Data d => d -> u) -> MultiArch -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MultiArch -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MultiArch -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MultiArch -> m MultiArch
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MultiArch -> m MultiArch
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MultiArch
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MultiArch -> c MultiArch
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MultiArch)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MultiArch)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MultiArch -> c MultiArch
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MultiArch -> c MultiArch
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MultiArch
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MultiArch
$ctoConstr :: MultiArch -> Constr
toConstr :: MultiArch -> Constr
$cdataTypeOf :: MultiArch -> DataType
dataTypeOf :: MultiArch -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MultiArch)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MultiArch)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MultiArch)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MultiArch)
$cgmapT :: (forall b. Data b => b -> b) -> MultiArch -> MultiArch
gmapT :: (forall b. Data b => b -> b) -> MultiArch -> MultiArch
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MultiArch -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MultiArch -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MultiArch -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MultiArch -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MultiArch -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MultiArch -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MultiArch -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MultiArch -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MultiArch -> m MultiArch
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MultiArch -> m MultiArch
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MultiArch -> m MultiArch
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MultiArch -> m MultiArch
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MultiArch -> m MultiArch
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MultiArch -> m MultiArch
Data, Typeable)

readMultiArch :: String -> MultiArch
readMultiArch :: [Char] -> MultiArch
readMultiArch [Char]
s =
    case Text -> [Char]
unpack (Text -> Text
strip ([Char] -> Text
pack [Char]
s)) of
      [Char]
"no" -> MultiArch
MANo
      [Char]
"same" -> MultiArch
MASame
      [Char]
"foreign" -> MultiArch
MAForeign
      [Char]
"allowed" -> MultiArch
MAAllowed
      [Char]
x -> [Char] -> MultiArch
forall a. HasCallStack => [Char] -> a
error ([Char] -> MultiArch) -> [Char] -> MultiArch
forall a b. (a -> b) -> a -> b
$ [Char]
"Invalid Multi-Arch string: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
x

instance Pretty (PP MultiArch) where
    pretty :: PP MultiArch -> Doc
pretty (PP MultiArch
MANo) = [Char] -> Doc
text [Char]
"no"
    pretty (PP MultiArch
MASame) = [Char] -> Doc
text [Char]
"same"
    pretty (PP MultiArch
MAForeign) = [Char] -> Doc
text [Char]
"foreign"
    pretty (PP MultiArch
MAAllowed) = [Char] -> Doc
text [Char]
"allowed"

-- Is this really all that is allowed here?  Doesn't Ubuntu have different areas?
data Area
    = Main
    | Contrib
    | NonFree
    deriving (ReadPrec [Area]
ReadPrec Area
Int -> ReadS Area
ReadS [Area]
(Int -> ReadS Area)
-> ReadS [Area] -> ReadPrec Area -> ReadPrec [Area] -> Read Area
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Area
readsPrec :: Int -> ReadS Area
$creadList :: ReadS [Area]
readList :: ReadS [Area]
$creadPrec :: ReadPrec Area
readPrec :: ReadPrec Area
$creadListPrec :: ReadPrec [Area]
readListPrec :: ReadPrec [Area]
Read, Area -> Area -> Bool
(Area -> Area -> Bool) -> (Area -> Area -> Bool) -> Eq Area
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Area -> Area -> Bool
== :: Area -> Area -> Bool
$c/= :: Area -> Area -> Bool
/= :: Area -> Area -> Bool
Eq, Eq Area
Eq Area =>
(Area -> Area -> Ordering)
-> (Area -> Area -> Bool)
-> (Area -> Area -> Bool)
-> (Area -> Area -> Bool)
-> (Area -> Area -> Bool)
-> (Area -> Area -> Area)
-> (Area -> Area -> Area)
-> Ord Area
Area -> Area -> Bool
Area -> Area -> Ordering
Area -> Area -> Area
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Area -> Area -> Ordering
compare :: Area -> Area -> Ordering
$c< :: Area -> Area -> Bool
< :: Area -> Area -> Bool
$c<= :: Area -> Area -> Bool
<= :: Area -> Area -> Bool
$c> :: Area -> Area -> Bool
> :: Area -> Area -> Bool
$c>= :: Area -> Area -> Bool
>= :: Area -> Area -> Bool
$cmax :: Area -> Area -> Area
max :: Area -> Area -> Area
$cmin :: Area -> Area -> Area
min :: Area -> Area -> Area
Ord, Int -> Area -> [Char] -> [Char]
[Area] -> [Char] -> [Char]
Area -> [Char]
(Int -> Area -> [Char] -> [Char])
-> (Area -> [Char]) -> ([Area] -> [Char] -> [Char]) -> Show Area
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
$cshowsPrec :: Int -> Area -> [Char] -> [Char]
showsPrec :: Int -> Area -> [Char] -> [Char]
$cshow :: Area -> [Char]
show :: Area -> [Char]
$cshowList :: [Area] -> [Char] -> [Char]
showList :: [Area] -> [Char] -> [Char]
Show, Typeable Area
Typeable Area =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Area -> c Area)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Area)
-> (Area -> Constr)
-> (Area -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Area))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Area))
-> ((forall b. Data b => b -> b) -> Area -> Area)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Area -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Area -> r)
-> (forall u. (forall d. Data d => d -> u) -> Area -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Area -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Area -> m Area)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Area -> m Area)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Area -> m Area)
-> Data Area
Area -> Constr
Area -> DataType
(forall b. Data b => b -> b) -> Area -> Area
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Area -> u
forall u. (forall d. Data d => d -> u) -> Area -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Area -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Area -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Area -> m Area
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Area -> m Area
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Area
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Area -> c Area
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Area)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Area)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Area -> c Area
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Area -> c Area
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Area
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Area
$ctoConstr :: Area -> Constr
toConstr :: Area -> Constr
$cdataTypeOf :: Area -> DataType
dataTypeOf :: Area -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Area)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Area)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Area)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Area)
$cgmapT :: (forall b. Data b => b -> b) -> Area -> Area
gmapT :: (forall b. Data b => b -> b) -> Area -> Area
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Area -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Area -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Area -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Area -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Area -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Area -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Area -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Area -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Area -> m Area
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Area -> m Area
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Area -> m Area
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Area -> m Area
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Area -> m Area
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Area -> m Area
Data, Typeable)

instance Pretty (PP Area) where
    pretty :: PP Area -> Doc
pretty (PP Area
Main) = [Char] -> Doc
text [Char]
"main"
    pretty (PP Area
Contrib) = [Char] -> Doc
text [Char]
"contrib"
    pretty (PP Area
NonFree) = [Char] -> Doc
text [Char]
"non-free"

{-
Create a debian maintainer field from the environment variables:

  DEBFULLNAME (preferred) or NAME
  DEBEMAIL (preferred) or EMAIL

More work could be done to match dch, but this is sufficient for
now. Here is what the man page for dch has to say:

 If the environment variable DEBFULLNAME is set, this will be used for
 the maintainer full name; if not, then NAME will be checked.  If the
 environment variable DEBEMAIL is set, this will be used for the email
 address.  If this variable has the form "name <email>", then the
 maintainer name will also be taken from here if neither DEBFULLNAME
 nor NAME is set.  If this variable is not set, the same test is
 performed on the environment variable EMAIL.  Next, if the full name
 has still not been determined, then use getpwuid(3) to determine the
 name from the pass‐word file.  If this fails, use the previous
 changelog entry.  For the email address, if it has not been set from
 DEBEMAIL or EMAIL, then look in /etc/mailname, then attempt to build
 it from the username and FQDN, otherwise use the email address in the
 previous changelog entry.  In other words, it’s a good idea to set
 DEBEMAIL and DEBFULLNAME when using this script.

-}
getCurrentDebianUser :: IO (Maybe NameAddr)
getCurrentDebianUser :: IO (Maybe NameAddr)
getCurrentDebianUser =
    do [([Char], [Char])]
env <- (([Char], [Char]) -> ([Char], [Char]))
-> [([Char], [Char])] -> [([Char], [Char])]
forall a b. (a -> b) -> [a] -> [b]
map (([Char] -> [Char]) -> ([Char], [Char]) -> ([Char], [Char])
forall b c d. (b -> c) -> (d, b) -> (d, c)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second [Char] -> [Char]
decodeString) ([([Char], [Char])] -> [([Char], [Char])])
-> IO [([Char], [Char])] -> IO [([Char], [Char])]
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` IO [([Char], [Char])]
getEnvironment
       Maybe NameAddr -> IO (Maybe NameAddr)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe NameAddr -> IO (Maybe NameAddr))
-> Maybe NameAddr -> IO (Maybe NameAddr)
forall a b. (a -> b) -> a -> b
$ do [Char]
fullname <- [Char] -> [([Char], [Char])] -> Maybe [Char]
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup [Char]
"DEBFULLNAME" [([Char], [Char])]
env Maybe [Char] -> Maybe [Char] -> Maybe [Char]
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` [Char] -> [([Char], [Char])] -> Maybe [Char]
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup [Char]
"NAME" [([Char], [Char])]
env
                   [Char]
email    <- [Char] -> [([Char], [Char])] -> Maybe [Char]
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup [Char]
"DEBEMAIL" [([Char], [Char])]
env Maybe [Char] -> Maybe [Char] -> Maybe [Char]
forall a. Maybe a -> Maybe a -> Maybe a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` [Char] -> [([Char], [Char])] -> Maybe [Char]
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup [Char]
"EMAIL" [([Char], [Char])]
env
                   ([Char] -> Maybe NameAddr)
-> (NameAddr -> Maybe NameAddr)
-> Either [Char] NameAddr
-> Maybe NameAddr
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Maybe NameAddr -> [Char] -> Maybe NameAddr
forall a b. a -> b -> a
const Maybe NameAddr
forall a. Maybe a
Nothing) NameAddr -> Maybe NameAddr
forall a. a -> Maybe a
Just ([Char] -> Either [Char] NameAddr
parseMaintainer ([Char]
fullname [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" <" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
email [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
">"))

haskellMaintainer :: NameAddr
haskellMaintainer :: NameAddr
haskellMaintainer =
    NameAddr { nameAddr_name :: Maybe [Char]
nameAddr_name = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
"Debian Haskell Group"
             , nameAddr_addr :: [Char]
nameAddr_addr = [Char]
"pkg-haskell-maintainers@lists.alioth.debian.org"}

-- | Turn the uploaders field of a cabal package into a list of
-- RFC2822 NameAddr values.
parseUploaders :: String -> Either String [NameAddr]
parseUploaders :: [Char] -> Either [Char] [NameAddr]
parseUploaders [Char]
x =
    (ParseError -> Either [Char] [NameAddr])
-> ([NameAddr] -> Either [Char] [NameAddr])
-> Either ParseError [NameAddr]
-> Either [Char] [NameAddr]
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either ([Char] -> Either [Char] [NameAddr]
forall a b. a -> Either a b
Left ([Char] -> Either [Char] [NameAddr])
-> (ParseError -> [Char]) -> ParseError -> Either [Char] [NameAddr]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError -> [Char]
forall a. Show a => a -> [Char]
show) [NameAddr] -> Either [Char] [NameAddr]
fixNameAddrs (Parsec [Char] () [NameAddr]
-> [Char] -> [Char] -> Either ParseError [NameAddr]
forall s t a.
Stream s Identity t =>
Parsec s () a -> [Char] -> s -> Either ParseError a
parse Parsec [Char] () [NameAddr]
forall s (m :: * -> *) u.
Stream s m Char =>
ParsecT s u m [NameAddr]
address [Char]
"" ([Char]
"Names: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ (Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
fixWhite [Char]
x [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
";"))
    -- either (\ e -> error ("Failure parsing uploader list: " ++ show x ++ " -> " ++ show e)) id $ 
    where
      fixWhite :: Char -> Char
fixWhite Char
c = if Char -> Bool
isSpace Char
c then Char
' ' else Char
c
      -- We absoletely need a name.
      fixNameAddrs :: [NameAddr] -> Either String [NameAddr]
      fixNameAddrs :: [NameAddr] -> Either [Char] [NameAddr]
fixNameAddrs [NameAddr]
xs = case (NameAddr -> Maybe NameAddr) -> [NameAddr] -> [NameAddr]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe NameAddr -> Maybe NameAddr
fixNameAddr [NameAddr]
xs of
                          [] -> [Char] -> Either [Char] [NameAddr]
forall a b. a -> Either a b
Left ([Char]
"No valid debian maintainers in " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
x)
                          [NameAddr]
xs' -> [NameAddr] -> Either [Char] [NameAddr]
forall a b. b -> Either a b
Right [NameAddr]
xs'
      fixNameAddr :: NameAddr -> Maybe NameAddr
      fixNameAddr :: NameAddr -> Maybe NameAddr
fixNameAddr NameAddr
y =
          case NameAddr -> Maybe [Char]
nameAddr_name NameAddr
y of
            Maybe [Char]
Nothing -> Maybe NameAddr
forall a. Maybe a
Nothing
            Maybe [Char]
_ -> NameAddr -> Maybe NameAddr
forall a. a -> Maybe a
Just NameAddr
y

-- | Parse a string containing a single NameAddr value.
parseMaintainer :: String -> Either String NameAddr
parseMaintainer :: [Char] -> Either [Char] NameAddr
parseMaintainer [Char]
x =
    case [Char] -> Either [Char] [NameAddr]
parseUploaders [Char]
x of
      Left [Char]
s -> [Char] -> Either [Char] NameAddr
forall a b. a -> Either a b
Left [Char]
s
      Right [NameAddr
y] -> NameAddr -> Either [Char] NameAddr
forall a b. b -> Either a b
Right NameAddr
y
      Right [] -> [Char] -> Either [Char] NameAddr
forall a b. a -> Either a b
Left ([Char] -> Either [Char] NameAddr)
-> [Char] -> Either [Char] NameAddr
forall a b. (a -> b) -> a -> b
$ [Char]
"Missing maintainer: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char] -> [Char]
forall a. Show a => a -> [Char]
show [Char]
x
      Right [NameAddr]
ys -> [Char] -> Either [Char] NameAddr
forall a b. a -> Either a b
Left ([Char] -> Either [Char] NameAddr)
-> [Char] -> Either [Char] NameAddr
forall a b. (a -> b) -> a -> b
$ [Char]
"Too many maintainers: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [NameAddr] -> [Char]
forall a. Show a => a -> [Char]
show [NameAddr]
ys


-- | Maintainer is a mandatory field, so we need a value we can use
-- when all else fails.
maintainerOfLastResort :: NameAddr
Right NameAddr
maintainerOfLastResort = [Char] -> Either [Char] NameAddr
parseMaintainer [Char]
"nobody <nobody@nowhere>"

-- | Official Debian license types as described in
-- <https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/#license-specification>.
data License
    = Public_Domain     -- ^ No license required for any purpose; the work is not subject to copyright in any jurisdiction.
    | Apache            -- ^ Apache license 1.0, 2.0.
    | Artistic          -- ^ Artistic license 1.0, 2.0.
    | BSD_2_Clause      -- ^ Berkeley software distribution license, 2-clause version.
    | BSD_3_Clause      -- ^ Berkeley software distribution license, 3-clause version.
    | BSD_4_Clause      -- ^ Berkeley software distribution license, 4-clause version.
    | ISC               -- ^ Internet Software Consortium, sometimes also known as the OpenBSD License.
    | CC_BY             -- ^ Creative Commons Attribution license 1.0, 2.0, 2.5, 3.0.
    | CC_BY_SA          -- ^ Creative Commons Attribution Share Alike license 1.0, 2.0, 2.5, 3.0.
    | CC_BY_ND          -- ^ Creative Commons Attribution No Derivatives license 1.0, 2.0, 2.5, 3.0.
    | CC_BY_NC          -- ^ Creative Commons Attribution Non-Commercial license 1.0, 2.0, 2.5, 3.0.
    | CC_BY_NC_SA       -- ^ Creative Commons Attribution Non-Commercial Share Alike license 1.0, 2.0, 2.5, 3.0.
    | CC_BY_NC_ND       -- ^ Creative Commons Attribution Non-Commercial No Derivatives license 1.0, 2.0, 2.5, 3.0.
    | CC0               -- ^ Creative Commons Zero 1.0 Universal. Omit "Universal" from the license version when forming the short name.
    | CDDL              -- ^ Common Development and Distribution License 1.0.
    | CPL               -- ^ IBM Common Public License.
    | EFL               -- ^ The Eiffel Forum License 1.0, 2.0.
    | Expat             -- ^ The Expat license.
    | GPL               -- ^ GNU General Public License 1.0, 2.0, 3.0.
    | LGPL              -- ^ GNU Lesser General Public License 2.1, 3.0, or GNU Library General Public License 2.0.
    | GFDL              -- ^ GNU Free Documentation License 1.0, 1.1, 1.2, or 1.3. Use GFDL-NIV instead if there are no Front-Cover or Back-Cover Texts or Invariant Sections.
    | GFDL_NIV          -- ^ GNU Free Documentation License, with no Front-Cover or Back-Cover Texts or Invariant Sections. Use the same version numbers as GFDL.
    | LPPL              -- ^ LaTeX Project Public License 1.0, 1.1, 1.2, 1.3c.
    | MPL               -- ^ Mozilla Public License 1.1.
    | Perl              -- ^ erl license (use "GPL-1+ or Artistic-1" instead)
    | Python            -- ^ Python license 2.0.
    | QPL               -- ^ Q Public License 1.0.
    | W3C               -- ^ W3C Software License For more information, consult the W3C Intellectual Rights FAQ.
    | Zlib              -- ^ zlib/libpng license.
    | Zope              -- ^ Zope Public License 1.0, 1.1, 2.0, 2.1.
    | OtherLicense String
                        -- ^ Any other license name
    deriving (ReadPrec [License]
ReadPrec License
Int -> ReadS License
ReadS [License]
(Int -> ReadS License)
-> ReadS [License]
-> ReadPrec License
-> ReadPrec [License]
-> Read License
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS License
readsPrec :: Int -> ReadS License
$creadList :: ReadS [License]
readList :: ReadS [License]
$creadPrec :: ReadPrec License
readPrec :: ReadPrec License
$creadListPrec :: ReadPrec [License]
readListPrec :: ReadPrec [License]
Read, Int -> License -> [Char] -> [Char]
[License] -> [Char] -> [Char]
License -> [Char]
(Int -> License -> [Char] -> [Char])
-> (License -> [Char])
-> ([License] -> [Char] -> [Char])
-> Show License
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
$cshowsPrec :: Int -> License -> [Char] -> [Char]
showsPrec :: Int -> License -> [Char] -> [Char]
$cshow :: License -> [Char]
show :: License -> [Char]
$cshowList :: [License] -> [Char] -> [Char]
showList :: [License] -> [Char] -> [Char]
Show, License -> License -> Bool
(License -> License -> Bool)
-> (License -> License -> Bool) -> Eq License
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: License -> License -> Bool
== :: License -> License -> Bool
$c/= :: License -> License -> Bool
/= :: License -> License -> Bool
Eq, Eq License
Eq License =>
(License -> License -> Ordering)
-> (License -> License -> Bool)
-> (License -> License -> Bool)
-> (License -> License -> Bool)
-> (License -> License -> Bool)
-> (License -> License -> License)
-> (License -> License -> License)
-> Ord License
License -> License -> Bool
License -> License -> Ordering
License -> License -> License
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: License -> License -> Ordering
compare :: License -> License -> Ordering
$c< :: License -> License -> Bool
< :: License -> License -> Bool
$c<= :: License -> License -> Bool
<= :: License -> License -> Bool
$c> :: License -> License -> Bool
> :: License -> License -> Bool
$c>= :: License -> License -> Bool
>= :: License -> License -> Bool
$cmax :: License -> License -> License
max :: License -> License -> License
$cmin :: License -> License -> License
min :: License -> License -> License
Ord, Typeable License
Typeable License =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> License -> c License)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c License)
-> (License -> Constr)
-> (License -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c License))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c License))
-> ((forall b. Data b => b -> b) -> License -> License)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> License -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> License -> r)
-> (forall u. (forall d. Data d => d -> u) -> License -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> License -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> License -> m License)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> License -> m License)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> License -> m License)
-> Data License
License -> Constr
License -> DataType
(forall b. Data b => b -> b) -> License -> License
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> License -> u
forall u. (forall d. Data d => d -> u) -> License -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> License -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> License -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> License -> m License
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> License -> m License
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c License
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> License -> c License
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c License)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c License)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> License -> c License
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> License -> c License
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c License
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c License
$ctoConstr :: License -> Constr
toConstr :: License -> Constr
$cdataTypeOf :: License -> DataType
dataTypeOf :: License -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c License)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c License)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c License)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c License)
$cgmapT :: (forall b. Data b => b -> b) -> License -> License
gmapT :: (forall b. Data b => b -> b) -> License -> License
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> License -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> License -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> License -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> License -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> License -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> License -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> License -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> License -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> License -> m License
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> License -> m License
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> License -> m License
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> License -> m License
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> License -> m License
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> License -> m License
Data, Typeable)

-- We need a license parse function that converts these strings back
-- into License values.
instance Pretty License where
    pretty :: License -> Doc
pretty License
Public_Domain = [Char] -> Doc
text [Char]
"public-domain"
    pretty License
Apache = [Char] -> Doc
text [Char]
"Apache"
    pretty License
Artistic = [Char] -> Doc
text [Char]
"Artistic"
    pretty License
BSD_2_Clause = [Char] -> Doc
text [Char]
"BSD-2-clause"
    pretty License
BSD_3_Clause = [Char] -> Doc
text [Char]
"BSD-3-clause"
    pretty License
BSD_4_Clause = [Char] -> Doc
text [Char]
"BSD-4-clause"
    pretty License
ISC = [Char] -> Doc
text [Char]
"ISC"
    pretty License
CC_BY = [Char] -> Doc
text [Char]
"CC-BY"
    pretty License
CC_BY_SA = [Char] -> Doc
text [Char]
"CC-BY-SA"
    pretty License
CC_BY_ND = [Char] -> Doc
text [Char]
"CC-BY-ND"
    pretty License
CC_BY_NC = [Char] -> Doc
text [Char]
"CC-BY-NC"
    pretty License
CC_BY_NC_SA = [Char] -> Doc
text [Char]
"CC-BY-NC-SA"
    pretty License
CC_BY_NC_ND = [Char] -> Doc
text [Char]
"CC-BY-NC-ND"
    pretty License
CC0 = [Char] -> Doc
text [Char]
"CC0"
    pretty License
CDDL = [Char] -> Doc
text [Char]
"CDDL"
    pretty License
CPL = [Char] -> Doc
text [Char]
"CPL"
    pretty License
EFL = [Char] -> Doc
text [Char]
"EFL"
    pretty License
Expat = [Char] -> Doc
text [Char]
"Expat"
    pretty License
GPL = [Char] -> Doc
text [Char]
"GPL"
    pretty License
LGPL = [Char] -> Doc
text [Char]
"LGPL"
    pretty License
GFDL = [Char] -> Doc
text [Char]
"GFDL"
    pretty License
GFDL_NIV = [Char] -> Doc
text [Char]
"GFDL-NIV"
    pretty License
LPPL = [Char] -> Doc
text [Char]
"LPPL"
    pretty License
MPL = [Char] -> Doc
text [Char]
"MPL"
    pretty License
Perl = [Char] -> Doc
text [Char]
"Perl"
    pretty License
Python = [Char] -> Doc
text [Char]
"Python"
    pretty License
QPL = [Char] -> Doc
text [Char]
"QPL"
    pretty License
W3C = [Char] -> Doc
text [Char]
"W3C"
    pretty License
Zlib = [Char] -> Doc
text [Char]
"Zlib"
    pretty License
Zope = [Char] -> Doc
text [Char]
"Zope"
    pretty (OtherLicense [Char]
s) = [Char] -> Doc
text [Char]
s

-- | Convert the Cabal license to a Debian license.  I would welcome input
-- on how to make this more correct.
fromCabalLicense :: Cabal.License -> License
fromCabalLicense :: License -> License
fromCabalLicense License
x =
    case License
x of
      Cabal.GPL Maybe Version
_ -> License
GPL -- FIXME - what about the version number?  same below
      Cabal.AGPL Maybe Version
_ -> [Char] -> License
OtherLicense (License -> [Char]
forall a. Show a => a -> [Char]
show License
x)
      Cabal.LGPL Maybe Version
_ -> License
LGPL
      License
Cabal.BSD3 -> License
BSD_3_Clause
      License
Cabal.BSD4 -> License
BSD_4_Clause
      License
Cabal.MIT -> License
Expat
      Cabal.Apache Maybe Version
_ -> License
Apache
      License
Cabal.PublicDomain -> License
Public_Domain
      License
Cabal.AllRightsReserved -> [Char] -> License
OtherLicense [Char]
"AllRightsReserved"
      License
Cabal.OtherLicense -> [Char] -> License
OtherLicense (License -> [Char]
forall a. Show a => a -> [Char]
show License
x)
      Cabal.UnknownLicense [Char]
_ -> [Char] -> License
OtherLicense (License -> [Char]
forall a. Show a => a -> [Char]
show License
x)
      Cabal.MPL Version
_ -> License
MPL
      License
Cabal.BSD2 -> License
BSD_2_Clause
      License
Cabal.ISC -> [Char] -> License
OtherLicense (License -> [Char]
forall a. Show a => a -> [Char]
show License
x)
      License
Cabal.UnspecifiedLicense -> [Char] -> License
OtherLicense (License -> [Char]
forall a. Show a => a -> [Char]
show License
x)

-- | Convert a Debian license to a Cabal license.  Additional cases
-- and corrections welcome.
toCabalLicense :: License -> Cabal.License
toCabalLicense :: License -> License
toCabalLicense License
x =
    -- This needs to be finished
    case License
x of
      License
BSD_2_Clause -> License
Cabal.BSD2
      License
BSD_3_Clause -> License
Cabal.BSD3
      License
BSD_4_Clause -> License
Cabal.BSD4
      License
Expat -> License
Cabal.MIT
      OtherLicense [Char]
s -> [Char] -> License
Cabal.UnknownLicense [Char]
s
      License
_ -> [Char] -> License
Cabal.UnknownLicense (License -> [Char]
forall a. Show a => a -> [Char]
show License
x)

invalidLicense :: Text -> License
invalidLicense :: Text -> License
invalidLicense = [Char] -> License
OtherLicense ([Char] -> License) -> (Text -> [Char]) -> Text -> License
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
unpack

-- | I think we need an actual parser for license names.
readLicense :: Text -> License
readLicense :: Text -> License
readLicense Text
t = let s :: [Char]
s = Text -> [Char]
unpack (Text -> Text
strip Text
t) in License -> Maybe License -> License
forall a. a -> Maybe a -> a
fromMaybe (Text -> License
invalidLicense Text
t) ([Char] -> Maybe License
forall a. Read a => [Char] -> Maybe a
readMaybe [Char]
s)