-- | 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
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
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
Ord, Int -> Flags -> ShowS
[Flags] -> ShowS
Flags -> String
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
Flags -> DataType
Flags -> Constr
(forall b. Data b => b -> b) -> Flags -> 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> Flags -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Flags -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Flags -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Flags -> [u]
gmapQr :: forall r r'.
(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 :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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
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
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
Ord, Int -> EnvSet -> ShowS
[EnvSet] -> ShowS
EnvSet -> String
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
EnvSet -> DataType
EnvSet -> Constr
(forall b. Data b => b -> b) -> EnvSet -> 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> EnvSet -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnvSet -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> EnvSet -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EnvSet -> [u]
gmapQr :: forall r r'.
(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 :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
Data, Typeable)

-- | A redundant data type, too lazy to expunge.
data DebType = Dev | Prof | Doc deriving (DebType -> DebType -> Bool
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
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
Ord, ReadPrec [DebType]
ReadPrec DebType
Int -> ReadS DebType
ReadS [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
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
DebType -> DataType
DebType -> Constr
(forall b. Data b => b -> b) -> DebType -> 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)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
MonadPlus m =>
(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 (m :: * -> *).
Monad m =>
(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 :: forall u. Int -> (forall d. Data d => d -> u) -> DebType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DebType -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> DebType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DebType -> [u]
gmapQr :: forall r r'.
(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 :: forall r r'.
(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 (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(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 (t :: * -> *) (c :: * -> *).
Typeable t =>
(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 (c :: * -> *).
(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 (c :: * -> *).
(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
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 :: forall (m :: * -> *). MonadIO m => [OptDescr (StateT Flags m ())]
flagOptions =
    [ forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"v" [String
"verbose"] (forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\ String
s -> Lens' Flags Int
verbosity forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= (forall a. Read a => (String -> a) -> String -> a
read' (\ String
s' -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"verbose: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show String
s') String
s :: Int)) String
"number")
             String
"Change the amount of progress messages generated",
      forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"n" [String
"dry-run", String
"compare"] (forall a. a -> ArgDescr a
NoArg (Lens' Flags Bool
dryRun 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.",
      forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"upgrade"] (forall a. a -> ArgDescr a
NoArg (Lens' Flags Bool
upgrade forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Bool
True))
             String
"Carefully upgrade an existing debianization",
      forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"roundtrip"] (forall a. a -> ArgDescr a
NoArg (Lens' Flags Bool
roundtrip forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= Bool
True))
             String
"Rountrip a debianization to normalize it",
      forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"ghc"] (forall a. a -> ArgDescr a
NoArg (Lens' Flags CompilerFlavor
compilerFlavor 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",
      forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"ghcjs"] (forall a. a -> ArgDescr a
NoArg (Lens' Flags CompilerFlavor
compilerFlavor 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",
      forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"hugs"] (forall a. a -> ArgDescr a
NoArg (Lens' Flags CompilerFlavor
compilerFlavor 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",
      forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"with-compiler"] (forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\ String
s -> forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"Invalid compiler id: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show String
s)
                                                        (\ CompilerFlavor
hc -> Lens' Flags CompilerFlavor
compilerFlavor forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= CompilerFlavor
hc)
                                                        (forall a. Read a => String -> Maybe a
readMaybe (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" ]),
      forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"f" [String
"flags"] (forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\ String
fs -> Lens' Flags (Set (FlagName, Bool))
cabalFlagAssignments forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => Set a -> Set a -> Set a
Set.union (forall a. Ord a => [a] -> Set a
Set.fromList (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."]),
      forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"" [String
"buildenvdir"] (forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\ String
s -> Lens' Flags EnvSet
buildEnv forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> b -> m ()
.= 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.",
      forall a. String -> [String] -> ArgDescr a -> String -> OptDescr a
Option String
"f" [String
"cabal-flags"] (forall a. (String -> a) -> String -> ArgDescr a
ReqArg (\ String
s -> Lens' Flags (Set (FlagName, Bool))
cabalFlagAssignments forall s (m :: * -> *) a b.
MonadState s m =>
ASetter s s a b -> (a -> b) -> m ()
%= (forall a. Ord a => Set a -> Set a -> Set a
Set.union (forall a. Ord a => [a] -> Set a
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 = forall a b. (a -> b) -> [a] -> [b]
map String -> (FlagName, Bool)
tagWithValue 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 (forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower String
name), Bool
False)
        tagWithValue String
name       = (String -> FlagName
mkFlagName (forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower String
name), Bool
True)