-- | The basic information required to load a Cabal or Debian package description.
{-# LANGUAGE DeriveDataTypeable, TemplateHaskell #-}
module Debian.Debianize.BasicInfo
    ( -- * Types
      Flags(..)
    , EnvSet(..)
    , DebType(..)
      -- * Lenses
    , verbosity
    , dryRun
    , upgrade
    , roundtrip
    , validate
    , compilerFlavor
    , cabalFlagAssignments
    , buildEnv
      -- * State Monad
    , flagOptions
    ) where

import Control.Lens
import Control.Monad.State (StateT)
import Control.Monad.Trans (MonadIO)
import Data.Char (toLower, toUpper)
import Data.Generics (Data, Typeable)
import Data.Set as Set (fromList, Set, union)
import Debian.Debianize.Prelude (read')
import Debian.Orphans ()
import Distribution.Compiler (CompilerFlavor(..))
import Distribution.PackageDescription as Cabal (FlagName, mkFlagName)
import Prelude hiding (break, lines, log, null, readFile, sum)
import System.Console.GetOpt (ArgDescr(ReqArg, NoArg), OptDescr(Option))
import System.FilePath ((</>))
import Text.Read (readMaybe)

-- | This record supplies enough information to locate and load a debianization
-- or a cabal file from the IO monad.
data Flags = Flags
    {
      Flags -> Int
_verbosity :: Int
    -- ^ Run with progress messages at the given level of verboseness.
    , Flags -> Bool
_dryRun :: Bool
    -- ^ Don't write any files or create any directories, just explain
    -- what would have been done.
    , Flags -> Bool
_upgrade :: Bool
    -- ^ Carefully upgrade the packaging
    , Flags -> Bool
_roundtrip :: Bool
    -- ^ Normalize a debianization (field order, whitespace) by round-tripping it.
    , Flags -> Bool
_validate :: Bool
    -- ^ Fail if the debianization already present doesn't match the
    -- one we are going to generate closely enough that it is safe to
    -- debianize during the run of dpkg-buildpackage, when Setup
    -- configure is run.  Specifically, the version number in the top
    -- changelog entry must match, and the sets of package names in
    -- the control file must match.
    , Flags -> CompilerFlavor
_compilerFlavor :: CompilerFlavor
    -- ^ Which compiler should we generate library packages for?  In theory a single
    -- deb could handle multiple compiler flavors, but the support tools are not ready
    -- for this as of right now (28 Jan 2015.)
    , Flags -> Set (FlagName, Bool)
_cabalFlagAssignments :: Set (FlagName, Bool)
    -- ^ Flags to pass to Cabal function finalizePackageDescription,
    -- this can be used to control the flags in the cabal file.  It
    -- can be supplied to the cabal-debian binary using the --flags
    -- option.
    , Flags -> EnvSet
_buildEnv :: EnvSet
    -- ^ Directory containing the build environment for which the
    -- debianization will be generated.  This determines which
    -- compiler will be available, which in turn determines which
    -- basic libraries can be provided by the compiler.  By default
    -- all the paths in EnvSet are "/".
    } deriving (Flags -> Flags -> Bool
(Flags -> Flags -> Bool) -> (Flags -> Flags -> Bool) -> Eq Flags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Flags -> Flags -> Bool
$c/= :: Flags -> Flags -> Bool
== :: Flags -> Flags -> Bool
$c== :: Flags -> Flags -> Bool
Eq, Eq Flags
Eq Flags
-> (Flags -> Flags -> Ordering)
-> (Flags -> Flags -> Bool)
-> (Flags -> Flags -> Bool)
-> (Flags -> Flags -> Bool)
-> (Flags -> Flags -> Bool)
-> (Flags -> Flags -> Flags)
-> (Flags -> Flags -> Flags)
-> Ord Flags
Flags -> Flags -> Bool
Flags -> Flags -> Ordering
Flags -> Flags -> Flags
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
min :: Flags -> Flags -> Flags
$cmin :: Flags -> Flags -> Flags
max :: Flags -> Flags -> Flags
$cmax :: Flags -> Flags -> Flags
>= :: Flags -> Flags -> Bool
$c>= :: Flags -> Flags -> Bool
> :: Flags -> Flags -> Bool
$c> :: Flags -> Flags -> Bool
<= :: Flags -> Flags -> Bool
$c<= :: Flags -> Flags -> Bool
< :: Flags -> Flags -> Bool
$c< :: Flags -> Flags -> Bool
compare :: Flags -> Flags -> Ordering
$ccompare :: Flags -> Flags -> Ordering
$cp1Ord :: Eq Flags
Ord, Int -> Flags -> ShowS
[Flags] -> ShowS
Flags -> String
(Int -> Flags -> ShowS)
-> (Flags -> String) -> ([Flags] -> ShowS) -> Show Flags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Flags] -> ShowS
$cshowList :: [Flags] -> ShowS
show :: Flags -> String
$cshow :: Flags -> String
showsPrec :: Int -> Flags -> ShowS
$cshowsPrec :: Int -> Flags -> ShowS
Show, Typeable Flags
DataType
Constr
Typeable Flags
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Flags -> c Flags)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Flags)
-> (Flags -> Constr)
-> (Flags -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Flags))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flags))
-> ((forall b. Data b => b -> b) -> Flags -> Flags)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flags -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flags -> r)
-> (forall u. (forall d. Data d => d -> u) -> Flags -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Flags -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Flags -> m Flags)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Flags -> m Flags)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Flags -> m Flags)
-> Data Flags
Flags -> DataType
Flags -> Constr
(forall b. Data b => b -> b) -> Flags -> Flags
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flags -> c Flags
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flags
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) -> Flags -> u
forall u. (forall d. Data d => d -> u) -> Flags -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flags -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flags -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Flags -> m Flags
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flags -> m Flags
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flags
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flags -> c Flags
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Flags)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flags)
$cFlags :: Constr
$tFlags :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Flags -> m Flags
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flags -> m Flags
gmapMp :: (forall d. Data d => d -> m d) -> Flags -> m Flags
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Flags -> m Flags
gmapM :: (forall d. Data d => d -> m d) -> Flags -> m Flags
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Flags -> m Flags
gmapQi :: Int -> (forall d. Data d => d -> u) -> Flags -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Flags -> u
gmapQ :: (forall d. Data d => d -> u) -> Flags -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Flags -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flags -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flags -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flags -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flags -> r
gmapT :: (forall b. Data b => b -> b) -> Flags -> Flags
$cgmapT :: (forall b. Data b => b -> b) -> Flags -> Flags
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flags)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flags)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Flags)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Flags)
dataTypeOf :: Flags -> DataType
$cdataTypeOf :: Flags -> DataType
toConstr :: Flags -> Constr
$ctoConstr :: Flags -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flags
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Flags
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flags -> c Flags
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Flags -> c Flags
$cp1Data :: Typeable Flags
Data, Typeable)

data EnvSet = EnvSet
    { EnvSet -> String
cleanOS :: FilePath  -- ^ The output of the debootstrap command
    , EnvSet -> String
dependOS :: FilePath -- ^ An environment with build dependencies installed
    , EnvSet -> String
buildOS :: FilePath  -- ^ An environment where we have built a package
    } deriving (EnvSet -> EnvSet -> Bool
(EnvSet -> EnvSet -> Bool)
-> (EnvSet -> EnvSet -> Bool) -> Eq EnvSet
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnvSet -> EnvSet -> Bool
$c/= :: EnvSet -> EnvSet -> Bool
== :: EnvSet -> EnvSet -> Bool
$c== :: EnvSet -> EnvSet -> Bool
Eq, Eq EnvSet
Eq EnvSet
-> (EnvSet -> EnvSet -> Ordering)
-> (EnvSet -> EnvSet -> Bool)
-> (EnvSet -> EnvSet -> Bool)
-> (EnvSet -> EnvSet -> Bool)
-> (EnvSet -> EnvSet -> Bool)
-> (EnvSet -> EnvSet -> EnvSet)
-> (EnvSet -> EnvSet -> EnvSet)
-> Ord EnvSet
EnvSet -> EnvSet -> Bool
EnvSet -> EnvSet -> Ordering
EnvSet -> EnvSet -> EnvSet
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
min :: EnvSet -> EnvSet -> EnvSet
$cmin :: EnvSet -> EnvSet -> EnvSet
max :: EnvSet -> EnvSet -> EnvSet
$cmax :: EnvSet -> EnvSet -> EnvSet
>= :: EnvSet -> EnvSet -> Bool
$c>= :: EnvSet -> EnvSet -> Bool
> :: EnvSet -> EnvSet -> Bool
$c> :: EnvSet -> EnvSet -> Bool
<= :: EnvSet -> EnvSet -> Bool
$c<= :: EnvSet -> EnvSet -> Bool
< :: EnvSet -> EnvSet -> Bool
$c< :: EnvSet -> EnvSet -> Bool
compare :: EnvSet -> EnvSet -> Ordering
$ccompare :: EnvSet -> EnvSet -> Ordering
$cp1Ord :: Eq EnvSet
Ord, Int -> EnvSet -> ShowS
[EnvSet] -> ShowS
EnvSet -> String
(Int -> EnvSet -> ShowS)
-> (EnvSet -> String) -> ([EnvSet] -> ShowS) -> Show EnvSet
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EnvSet] -> ShowS
$cshowList :: [EnvSet] -> ShowS
show :: EnvSet -> String
$cshow :: EnvSet -> String
showsPrec :: Int -> EnvSet -> ShowS
$cshowsPrec :: Int -> EnvSet -> ShowS
Show, Typeable EnvSet
DataType
Constr
Typeable EnvSet
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EnvSet -> c EnvSet)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EnvSet)
-> (EnvSet -> Constr)
-> (EnvSet -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EnvSet))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnvSet))
-> ((forall b. Data b => b -> b) -> EnvSet -> EnvSet)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EnvSet -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EnvSet -> r)
-> (forall u. (forall d. Data d => d -> u) -> EnvSet -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> EnvSet -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EnvSet -> m EnvSet)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EnvSet -> m EnvSet)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EnvSet -> m EnvSet)
-> Data EnvSet
EnvSet -> DataType
EnvSet -> Constr
(forall b. Data b => b -> b) -> EnvSet -> EnvSet
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvSet -> c EnvSet
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvSet
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) -> EnvSet -> u
forall u. (forall d. Data d => d -> u) -> EnvSet -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EnvSet -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EnvSet -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnvSet -> m EnvSet
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvSet -> m EnvSet
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvSet
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvSet -> c EnvSet
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnvSet)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnvSet)
$cEnvSet :: Constr
$tEnvSet :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> EnvSet -> m EnvSet
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvSet -> m EnvSet
gmapMp :: (forall d. Data d => d -> m d) -> EnvSet -> m EnvSet
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvSet -> m EnvSet
gmapM :: (forall d. Data d => d -> m d) -> EnvSet -> m EnvSet
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnvSet -> m EnvSet
gmapQi :: Int -> (forall d. Data d => d -> u) -> EnvSet -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnvSet -> u
gmapQ :: (forall d. Data d => d -> u) -> EnvSet -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EnvSet -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EnvSet -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EnvSet -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EnvSet -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EnvSet -> r
gmapT :: (forall b. Data b => b -> b) -> EnvSet -> EnvSet
$cgmapT :: (forall b. Data b => b -> b) -> EnvSet -> EnvSet
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnvSet)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnvSet)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c EnvSet)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnvSet)
dataTypeOf :: EnvSet -> DataType
$cdataTypeOf :: EnvSet -> DataType
toConstr :: EnvSet -> Constr
$ctoConstr :: EnvSet -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvSet
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvSet
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvSet -> c EnvSet
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvSet -> c EnvSet
$cp1Data :: Typeable EnvSet
Data, Typeable)

-- | A redundant data type, too lazy to expunge.
data DebType = Dev | Prof | Doc deriving (DebType -> DebType -> Bool
(DebType -> DebType -> Bool)
-> (DebType -> DebType -> Bool) -> Eq DebType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DebType -> DebType -> Bool
$c/= :: DebType -> DebType -> Bool
== :: DebType -> DebType -> Bool
$c== :: DebType -> DebType -> Bool
Eq, Eq DebType
Eq DebType
-> (DebType -> DebType -> Ordering)
-> (DebType -> DebType -> Bool)
-> (DebType -> DebType -> Bool)
-> (DebType -> DebType -> Bool)
-> (DebType -> DebType -> Bool)
-> (DebType -> DebType -> DebType)
-> (DebType -> DebType -> DebType)
-> Ord DebType
DebType -> DebType -> Bool
DebType -> DebType -> Ordering
DebType -> DebType -> DebType
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
min :: DebType -> DebType -> DebType
$cmin :: DebType -> DebType -> DebType
max :: DebType -> DebType -> DebType
$cmax :: DebType -> DebType -> DebType
>= :: DebType -> DebType -> Bool
$c>= :: DebType -> DebType -> Bool
> :: DebType -> DebType -> Bool
$c> :: DebType -> DebType -> Bool
<= :: DebType -> DebType -> Bool
$c<= :: DebType -> DebType -> Bool
< :: DebType -> DebType -> Bool
$c< :: DebType -> DebType -> Bool
compare :: DebType -> DebType -> Ordering
$ccompare :: DebType -> DebType -> Ordering
$cp1Ord :: Eq DebType
Ord, ReadPrec [DebType]
ReadPrec DebType
Int -> ReadS DebType
ReadS [DebType]
(Int -> ReadS DebType)
-> ReadS [DebType]
-> ReadPrec DebType
-> ReadPrec [DebType]
-> Read DebType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DebType]
$creadListPrec :: ReadPrec [DebType]
readPrec :: ReadPrec DebType
$creadPrec :: ReadPrec DebType
readList :: ReadS [DebType]
$creadList :: ReadS [DebType]
readsPrec :: Int -> ReadS DebType
$creadsPrec :: Int -> ReadS DebType
Read, Int -> DebType -> ShowS
[DebType] -> ShowS
DebType -> String
(Int -> DebType -> ShowS)
-> (DebType -> String) -> ([DebType] -> ShowS) -> Show DebType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DebType] -> ShowS
$cshowList :: [DebType] -> ShowS
show :: DebType -> String
$cshow :: DebType -> String
showsPrec :: Int -> DebType -> ShowS
$cshowsPrec :: Int -> DebType -> ShowS
Show, Typeable DebType
DataType
Constr
Typeable DebType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DebType -> c DebType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DebType)
-> (DebType -> Constr)
-> (DebType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DebType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DebType))
-> ((forall b. Data b => b -> b) -> DebType -> DebType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DebType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DebType -> r)
-> (forall u. (forall d. Data d => d -> u) -> DebType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DebType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DebType -> m DebType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DebType -> m DebType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DebType -> m DebType)
-> Data DebType
DebType -> DataType
DebType -> Constr
(forall b. Data b => b -> b) -> DebType -> DebType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebType -> c DebType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebType
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) -> DebType -> u
forall u. (forall d. Data d => d -> u) -> DebType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DebType -> m DebType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DebType -> m DebType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebType -> c DebType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DebType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DebType)
$cDoc :: Constr
$cProf :: Constr
$cDev :: Constr
$tDebType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DebType -> m DebType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DebType -> m DebType
gmapMp :: (forall d. Data d => d -> m d) -> DebType -> m DebType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DebType -> m DebType
gmapM :: (forall d. Data d => d -> m d) -> DebType -> m DebType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DebType -> m DebType
gmapQi :: Int -> (forall d. Data d => d -> u) -> DebType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DebType -> u
gmapQ :: (forall d. Data d => d -> u) -> DebType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DebType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebType -> r
gmapT :: (forall b. Data b => b -> b) -> DebType -> DebType
$cgmapT :: (forall b. Data b => b -> b) -> DebType -> DebType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DebType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DebType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DebType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DebType)
dataTypeOf :: DebType -> DataType
$cdataTypeOf :: DebType -> DataType
toConstr :: DebType -> Constr
$ctoConstr :: DebType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebType -> c DebType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebType -> c DebType
$cp1Data :: Typeable DebType
Data, Typeable)



-- Build the lenses
$(makeLenses ''Flags)

-- | Command line options which build a function that modifies a
-- state monad value of type 'Flags'
flagOptions :: MonadIO m => [OptDescr (StateT Flags m ())]
flagOptions :: [OptDescr (StateT Flags m ())]
flagOptions =
    [ String
-> [String]
-> ArgDescr (StateT Flags m ())
-> String
-> OptDescr (StateT Flags m ())
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"v" [String
"verbose"] ((String -> StateT Flags m ())
-> String -> ArgDescr (StateT Flags m ())
forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\ String
s -> (Int -> Identity Int) -> Flags -> Identity Flags
Lens' Flags Int
verbosity ((Int -> Identity Int) -> Flags -> Identity Flags)
-> Int -> StateT Flags m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= ((String -> Int) -> String -> Int
forall a. Read a => (String -> a) -> String -> a
read' (\ String
s' -> String -> Int
forall a. HasCallStack => String -> a
error (String -> Int) -> String -> Int
forall a b. (a -> b) -> a -> b
$ String
"verbose: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
s') String
s :: Int)) String
"number")
             String
"Change the amount of progress messages generated",
      String
-> [String]
-> ArgDescr (StateT Flags m ())
-> String
-> OptDescr (StateT Flags m ())
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"n" [String
"dry-run", String
"compare"] (StateT Flags m () -> ArgDescr (StateT Flags m ())
forall a. a -> ArgDescr a
NoArg ((Bool -> Identity Bool) -> Flags -> Identity Flags
Lens' Flags Bool
dryRun ((Bool -> Identity Bool) -> Flags -> Identity Flags)
-> Bool -> StateT Flags m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Bool
True))
             String
"Just compare the existing debianization to the one we would generate.",
      String
-> [String]
-> ArgDescr (StateT Flags m ())
-> String
-> OptDescr (StateT Flags m ())
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"upgrade"] (StateT Flags m () -> ArgDescr (StateT Flags m ())
forall a. a -> ArgDescr a
NoArg ((Bool -> Identity Bool) -> Flags -> Identity Flags
Lens' Flags Bool
upgrade ((Bool -> Identity Bool) -> Flags -> Identity Flags)
-> Bool -> StateT Flags m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Bool
True))
             String
"Carefully upgrade an existing debianization",
      String
-> [String]
-> ArgDescr (StateT Flags m ())
-> String
-> OptDescr (StateT Flags m ())
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"roundtrip"] (StateT Flags m () -> ArgDescr (StateT Flags m ())
forall a. a -> ArgDescr a
NoArg ((Bool -> Identity Bool) -> Flags -> Identity Flags
Lens' Flags Bool
roundtrip ((Bool -> Identity Bool) -> Flags -> Identity Flags)
-> Bool -> StateT Flags m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Bool
True))
             String
"Rountrip a debianization to normalize it",
      String
-> [String]
-> ArgDescr (StateT Flags m ())
-> String
-> OptDescr (StateT Flags m ())
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"ghc"] (StateT Flags m () -> ArgDescr (StateT Flags m ())
forall a. a -> ArgDescr a
NoArg ((CompilerFlavor -> Identity CompilerFlavor)
-> Flags -> Identity Flags
Lens' Flags CompilerFlavor
compilerFlavor ((CompilerFlavor -> Identity CompilerFlavor)
 -> Flags -> Identity Flags)
-> CompilerFlavor -> StateT Flags m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= CompilerFlavor
GHC)) String
"Generate packages for GHC - same as --with-compiler GHC",
      String
-> [String]
-> ArgDescr (StateT Flags m ())
-> String
-> OptDescr (StateT Flags m ())
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"ghcjs"] (StateT Flags m () -> ArgDescr (StateT Flags m ())
forall a. a -> ArgDescr a
NoArg ((CompilerFlavor -> Identity CompilerFlavor)
-> Flags -> Identity Flags
Lens' Flags CompilerFlavor
compilerFlavor ((CompilerFlavor -> Identity CompilerFlavor)
 -> Flags -> Identity Flags)
-> CompilerFlavor -> StateT Flags m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= CompilerFlavor
GHCJS)) String
"Generate packages for GHCJS - same as --with-compiler GHCJS",
      String
-> [String]
-> ArgDescr (StateT Flags m ())
-> String
-> OptDescr (StateT Flags m ())
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"hugs"] (StateT Flags m () -> ArgDescr (StateT Flags m ())
forall a. a -> ArgDescr a
NoArg ((CompilerFlavor -> Identity CompilerFlavor)
-> Flags -> Identity Flags
Lens' Flags CompilerFlavor
compilerFlavor ((CompilerFlavor -> Identity CompilerFlavor)
 -> Flags -> Identity Flags)
-> CompilerFlavor -> StateT Flags m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= CompilerFlavor
Hugs)) String
"Generate packages for Hugs - same as --with-compiler GHC",
      String
-> [String]
-> ArgDescr (StateT Flags m ())
-> String
-> OptDescr (StateT Flags m ())
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"with-compiler"] ((String -> StateT Flags m ())
-> String -> ArgDescr (StateT Flags m ())
forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\ String
s -> StateT Flags m ()
-> (CompilerFlavor -> StateT Flags m ())
-> Maybe CompilerFlavor
-> StateT Flags m ()
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> StateT Flags m ()
forall a. HasCallStack => String -> a
error (String -> StateT Flags m ()) -> String -> StateT Flags m ()
forall a b. (a -> b) -> a -> b
$ String
"Invalid compiler id: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show String
s)
                                                        (\ CompilerFlavor
hc -> (CompilerFlavor -> Identity CompilerFlavor)
-> Flags -> Identity Flags
Lens' Flags CompilerFlavor
compilerFlavor ((CompilerFlavor -> Identity CompilerFlavor)
 -> Flags -> Identity Flags)
-> CompilerFlavor -> StateT Flags m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= CompilerFlavor
hc)
                                                        (String -> Maybe CompilerFlavor
forall a. Read a => String -> Maybe a
readMaybe ((Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toUpper String
s) :: Maybe CompilerFlavor)) String
"COMPILER")
             ([String] -> String
unlines [ String
"Generate packages for this CompilerFlavor" ]),
      String
-> [String]
-> ArgDescr (StateT Flags m ())
-> String
-> OptDescr (StateT Flags m ())
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"f" [String
"flags"] ((String -> StateT Flags m ())
-> String -> ArgDescr (StateT Flags m ())
forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\ String
fs -> (Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> Flags -> Identity Flags
Lens' Flags (Set (FlagName, Bool))
cabalFlagAssignments ((Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
 -> Flags -> Identity Flags)
-> (Set (FlagName, Bool) -> Set (FlagName, Bool))
-> StateT Flags m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Set (FlagName, Bool)
-> Set (FlagName, Bool) -> Set (FlagName, Bool)
forall a. Ord a => Set a -> Set a -> Set a
Set.union ([(FlagName, Bool)] -> Set (FlagName, Bool)
forall a. Ord a => [a] -> Set a
Set.fromList (String -> [(FlagName, Bool)]
flagList String
fs)))) String
"FLAGS")
      -- Option "f" ["flags"] (ReqArg (\ fs p -> foldl (\ p' x -> p' {cabalFlagAssignments_ = Set.insert x (cabalFlagAssignments_ p')}) p (flagList fs)) "FLAGS")
             ([String] -> String
unlines [ String
"Flags to pass to the finalizePackageDescription function in"
                      , String
"Distribution.PackageDescription.Configuration when loading the cabal file."]),
      String
-> [String]
-> ArgDescr (StateT Flags m ())
-> String
-> OptDescr (StateT Flags m ())
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"buildenvdir"] ((String -> StateT Flags m ())
-> String -> ArgDescr (StateT Flags m ())
forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\ String
s -> (EnvSet -> Identity EnvSet) -> Flags -> Identity Flags
Lens' Flags EnvSet
buildEnv ((EnvSet -> Identity EnvSet) -> Flags -> Identity Flags)
-> EnvSet -> StateT Flags m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= EnvSet :: String -> String -> String -> EnvSet
EnvSet {cleanOS :: String
cleanOS = String
s String -> ShowS
</> String
"clean", dependOS :: String
dependOS = String
s String -> ShowS
</> String
"depend", buildOS :: String
buildOS = String
s String -> ShowS
</> String
"build"}) String
"PATH")
             String
"Directory containing the three build environments, clean, depend, and build.",
      String
-> [String]
-> ArgDescr (StateT Flags m ())
-> String
-> OptDescr (StateT Flags m ())
forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"f" [String
"cabal-flags"] ((String -> StateT Flags m ())
-> String -> ArgDescr (StateT Flags m ())
forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\ String
s -> (Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
-> Flags -> Identity Flags
Lens' Flags (Set (FlagName, Bool))
cabalFlagAssignments ((Set (FlagName, Bool) -> Identity (Set (FlagName, Bool)))
 -> Flags -> Identity Flags)
-> (Set (FlagName, Bool) -> Set (FlagName, Bool))
-> StateT Flags m ()
forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (Set (FlagName, Bool)
-> Set (FlagName, Bool) -> Set (FlagName, Bool)
forall a. Ord a => Set a -> Set a -> Set a
Set.union ([(FlagName, Bool)] -> Set (FlagName, Bool)
forall a. Ord a => [a] -> Set a
fromList (String -> [(FlagName, Bool)]
flagList String
s)))) String
"FLAG FLAG ...")
             String
"Flags to pass to cabal configure with the --flags= option "
      ]

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