{-# LANGUAGE DeriveDataTypeable, CPP #-}
{-# OPTIONS_GHC -w -fno-cse #-}

module CabalBounds.Args
   ( Args(..)
   , get
   , defaultDrop
   , defaultUpdate
   , defaultDump
   , defaultLibs
   , defaultFormat
   ) where

import System.Console.CmdArgs hiding (ignore)
import qualified System.Console.CmdArgs as CmdArgs
import CabalBounds.VersionComp (VersionComp(..))

#ifdef CABAL
import Data.Version (showVersion)
import Paths_cabal_bounds (version)
#endif

data Args = Drop { Args -> Bool
upper      :: Bool
                 , Args -> Bool
library    :: Bool
                 , Args -> [FilePath]
executable :: [String]
                 , Args -> [FilePath]
testSuite  :: [String]
                 , Args -> [FilePath]
benchmark  :: [String]
                 , Args -> [FilePath]
only       :: [String]
                 , Args -> [FilePath]
ignore     :: [String]
                 , Args -> Maybe FilePath
output     :: Maybe FilePath
                 , Args -> Maybe FilePath
cabalFile  :: Maybe FilePath
                 }
          | Update { Args -> Bool
lower           :: Bool
                   , upper           :: Bool
                   , Args -> Maybe VersionComp
lowerComp       :: Maybe VersionComp
                   , Args -> Maybe VersionComp
upperComp       :: Maybe VersionComp
                   , library         :: Bool
                   , executable      :: [String]
                   , testSuite       :: [String]
                   , benchmark       :: [String]
                   , only            :: [String]
                   , ignore          :: [String]
                   , Args -> Bool
missing         :: Bool
                   , output          :: Maybe FilePath
                   , Args -> FilePath
fromFile        :: FilePath
                   , Args -> FilePath
haskellPlatform :: String
                   , cabalFile       :: Maybe FilePath
                   , Args -> Maybe FilePath
setupConfigFile :: Maybe FilePath
                   , Args -> Maybe FilePath
planFile        :: Maybe FilePath
                   }
          | Dump { only       :: [String]
                 , ignore     :: [String]
                 , output     :: Maybe FilePath
                 , Args -> [FilePath]
cabalFiles :: [FilePath]
                 }
          | Libs { only            :: [String]
                 , ignore          :: [String]
                 , output          :: Maybe FilePath
                 , fromFile        :: FilePath
                 , haskellPlatform :: String
                 , cabalFile       :: Maybe FilePath
                 , setupConfigFile :: Maybe FilePath
                 , planFile        :: Maybe FilePath
                 }
          | Format { output    :: Maybe FilePath
                   , cabalFile :: Maybe FilePath
                   }
          deriving (Typeable Args
Typeable Args =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Args -> c Args)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Args)
-> (Args -> Constr)
-> (Args -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Args))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Args))
-> ((forall b. Data b => b -> b) -> Args -> Args)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Args -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Args -> r)
-> (forall u. (forall d. Data d => d -> u) -> Args -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Args -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Args -> m Args)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Args -> m Args)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Args -> m Args)
-> Data Args
Args -> Constr
Args -> DataType
(forall b. Data b => b -> b) -> Args -> Args
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) -> Args -> u
forall u. (forall d. Data d => d -> u) -> Args -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Args -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Args -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Args -> m Args
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Args -> m Args
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Args
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Args -> c Args
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Args)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Args)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Args -> c Args
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Args -> c Args
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Args
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Args
$ctoConstr :: Args -> Constr
toConstr :: Args -> Constr
$cdataTypeOf :: Args -> DataType
dataTypeOf :: Args -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Args)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Args)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Args)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Args)
$cgmapT :: (forall b. Data b => b -> b) -> Args -> Args
gmapT :: (forall b. Data b => b -> b) -> Args -> Args
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Args -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Args -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Args -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Args -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Args -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Args -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Args -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Args -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Args -> m Args
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Args -> m Args
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Args -> m Args
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Args -> m Args
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Args -> m Args
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Args -> m Args
Data, Typeable, Int -> Args -> ShowS
[Args] -> ShowS
Args -> FilePath
(Int -> Args -> ShowS)
-> (Args -> FilePath) -> ([Args] -> ShowS) -> Show Args
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Args -> ShowS
showsPrec :: Int -> Args -> ShowS
$cshow :: Args -> FilePath
show :: Args -> FilePath
$cshowList :: [Args] -> ShowS
showList :: [Args] -> ShowS
Show, Args -> Args -> Bool
(Args -> Args -> Bool) -> (Args -> Args -> Bool) -> Eq Args
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Args -> Args -> Bool
== :: Args -> Args -> Bool
$c/= :: Args -> Args -> Bool
/= :: Args -> Args -> Bool
Eq)


get :: IO Args
get :: IO Args
get = Mode (CmdArgs Args) -> IO Args
forall a. Mode (CmdArgs a) -> IO a
cmdArgsRun (Mode (CmdArgs Args) -> IO Args)
-> (Args -> Mode (CmdArgs Args)) -> Args -> IO Args
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Args -> Mode (CmdArgs Args)
forall a. Data a => a -> Mode (CmdArgs a)
cmdArgsMode (Args -> IO Args) -> Args -> IO Args
forall a b. (a -> b) -> a -> b
$ [Args] -> Args
forall val. Data val => [val] -> val
modes [Args
dropArgs, Args
updateArgs, Args
dumpArgs, Args
libsArgs, Args
formatArgs]
   Args -> Ann -> Args
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
program FilePath
"cabal-bounds"
   Args -> Ann -> Args
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
summary FilePath
summaryInfo
   Args -> Ann -> Args
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"A command line program for managing the bounds/versions of the dependencies in a cabal file."
   Args -> Ann -> Args
forall val. Data val => val -> Ann -> val
&= [Ann] -> Ann
helpArg [Ann
explicit, FilePath -> Ann
name FilePath
"help", FilePath -> Ann
name FilePath
"h"]
   Args -> Ann -> Args
forall val. Data val => val -> Ann -> val
&= [Ann] -> Ann
versionArg [Ann
explicit, FilePath -> Ann
name FilePath
"version", FilePath -> Ann
name FilePath
"v", FilePath -> Ann
summary FilePath
versionInfo]
   where
      summaryInfo :: FilePath
summaryInfo = FilePath
""


defaultDrop :: Args
defaultDrop :: Args
defaultDrop = Drop
   { upper :: Bool
upper           = Bool
forall a. Default a => a
def
   , library :: Bool
library         = Bool
forall a. Default a => a
def
   , executable :: [FilePath]
executable      = [FilePath]
forall a. Default a => a
def
   , testSuite :: [FilePath]
testSuite       = [FilePath]
forall a. Default a => a
def
   , benchmark :: [FilePath]
benchmark       = [FilePath]
forall a. Default a => a
def
   , only :: [FilePath]
only            = [FilePath]
forall a. Default a => a
def
   , ignore :: [FilePath]
ignore          = [FilePath]
forall a. Default a => a
def
   , output :: Maybe FilePath
output          = Maybe FilePath
forall a. Default a => a
def
   , cabalFile :: Maybe FilePath
cabalFile       = Maybe FilePath
forall a. Default a => a
def
   }


defaultUpdate :: Args
defaultUpdate :: Args
defaultUpdate = Update
   { lower :: Bool
lower           = Bool
forall a. Default a => a
def
   , upper :: Bool
upper           = Bool
forall a. Default a => a
def
   , lowerComp :: Maybe VersionComp
lowerComp       = Maybe VersionComp
forall a. Default a => a
def
   , upperComp :: Maybe VersionComp
upperComp       = Maybe VersionComp
forall a. Default a => a
def
   , library :: Bool
library         = Bool
forall a. Default a => a
def
   , executable :: [FilePath]
executable      = [FilePath]
forall a. Default a => a
def
   , testSuite :: [FilePath]
testSuite       = [FilePath]
forall a. Default a => a
def
   , benchmark :: [FilePath]
benchmark       = [FilePath]
forall a. Default a => a
def
   , only :: [FilePath]
only            = [FilePath]
forall a. Default a => a
def
   , ignore :: [FilePath]
ignore          = [FilePath]
forall a. Default a => a
def
   , missing :: Bool
missing         = Bool
forall a. Default a => a
def
   , output :: Maybe FilePath
output          = Maybe FilePath
forall a. Default a => a
def
   , fromFile :: FilePath
fromFile        = FilePath
forall a. Default a => a
def
   , haskellPlatform :: FilePath
haskellPlatform = FilePath
forall a. Default a => a
def
   , cabalFile :: Maybe FilePath
cabalFile       = Maybe FilePath
forall a. Default a => a
def
   , setupConfigFile :: Maybe FilePath
setupConfigFile = Maybe FilePath
forall a. Default a => a
def
   , planFile :: Maybe FilePath
planFile        = Maybe FilePath
forall a. Default a => a
def
   }


defaultDump :: Args
defaultDump :: Args
defaultDump = Dump
   { only :: [FilePath]
only       = [FilePath]
forall a. Default a => a
def
   , ignore :: [FilePath]
ignore     = [FilePath]
forall a. Default a => a
def
   , output :: Maybe FilePath
output     = Maybe FilePath
forall a. Default a => a
def
   , cabalFiles :: [FilePath]
cabalFiles = [FilePath]
forall a. Default a => a
def
   }


defaultLibs :: Args
defaultLibs :: Args
defaultLibs = Libs
   { only :: [FilePath]
only            = [FilePath]
forall a. Default a => a
def
   , ignore :: [FilePath]
ignore          = [FilePath]
forall a. Default a => a
def
   , output :: Maybe FilePath
output          = Maybe FilePath
forall a. Default a => a
def
   , fromFile :: FilePath
fromFile        = FilePath
forall a. Default a => a
def
   , haskellPlatform :: FilePath
haskellPlatform = FilePath
forall a. Default a => a
def
   , cabalFile :: Maybe FilePath
cabalFile       = Maybe FilePath
forall a. Default a => a
def
   , setupConfigFile :: Maybe FilePath
setupConfigFile = Maybe FilePath
forall a. Default a => a
def
   , planFile :: Maybe FilePath
planFile        = Maybe FilePath
forall a. Default a => a
def
   }


defaultFormat :: Args
defaultFormat :: Args
defaultFormat = Format
   { output :: Maybe FilePath
output    = Maybe FilePath
forall a. Default a => a
def
   , cabalFile :: Maybe FilePath
cabalFile = Maybe FilePath
forall a. Default a => a
def
   }


dropArgs :: Args
dropArgs :: Args
dropArgs = Drop
   { upper :: Bool
upper      = Bool
forall a. Default a => a
def Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= Ann
explicit Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"upper" Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"U"
                      Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Only the upper bound is dropped, otherwise both - the lower and upper - bounds are dropped."
   , library :: Bool
library    = Bool
forall a. Default a => a
def Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= Ann
explicit Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"library" Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"l" Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Only the bounds of the library are modified."
   , executable :: [FilePath]
executable = [FilePath]
forall a. Default a => a
def [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"NAME" [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Only the bounds of the executable are modified."
   , testSuite :: [FilePath]
testSuite  = [FilePath]
forall a. Default a => a
def [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"NAME" [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Only the bounds of the test suite are modified."
   , benchmark :: [FilePath]
benchmark  = [FilePath]
forall a. Default a => a
def [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"NAME" [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Only the bounds of the benchmark are modified."
   , only :: [FilePath]
only       = [FilePath]
forall a. Default a => a
def [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= Ann
explicit [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"DEPENDENCY" [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"only" [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"O"
                      [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Only the bounds of the dependency are modified."
   , ignore :: [FilePath]
ignore     = [FilePath]
forall a. Default a => a
def [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= Ann
explicit [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"DEPENDENCY" [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"ignore" [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"I"
                      [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"This dependency is ignored, not modified in any way."
   , output :: Maybe FilePath
output     = Maybe FilePath
forall a. Default a => a
def Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= Ann
explicit Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"FILE" Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"output" Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"o"
                      Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Save modified cabal file to file, if empty, the cabal file is modified inplace."
   , cabalFile :: Maybe FilePath
cabalFile  = Maybe FilePath
forall a. Default a => a
def Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= Ann
CmdArgs.ignore
   }


updateArgs :: Args
updateArgs :: Args
updateArgs = Update
   { lower :: Bool
lower           = Bool
forall a. Default a => a
def Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= Ann
explicit Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"lower" Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"L"
                           Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Only the lower bound is updated. The same as using '--lowercomp=minor'."
   , upper :: Bool
upper           = Bool
forall a. Default a => a
def Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= Ann
explicit Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"upper" Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"U"
                           Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Only the upper bound is updated. The same as using '--uppercomp=major2'."
   , lowerComp :: Maybe VersionComp
lowerComp       = Maybe VersionComp
forall a. Default a => a
def Maybe VersionComp -> Ann -> Maybe VersionComp
forall val. Data val => val -> Ann -> val
&= Ann
explicit Maybe VersionComp -> Ann -> Maybe VersionComp
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"lowercomp"
                           Maybe VersionComp -> Ann -> Maybe VersionComp
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Only the lower bound is updated with the specified version component. (major1, major2 or minor)"
   , upperComp :: Maybe VersionComp
upperComp       = Maybe VersionComp
forall a. Default a => a
def Maybe VersionComp -> Ann -> Maybe VersionComp
forall val. Data val => val -> Ann -> val
&= Ann
explicit Maybe VersionComp -> Ann -> Maybe VersionComp
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"uppercomp"
                           Maybe VersionComp -> Ann -> Maybe VersionComp
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Only the upper bound is updated with the specified version component. (major1, major2 or minor)"
   , missing :: Bool
missing         = Bool
forall a. Default a => a
def Bool -> Ann -> Bool
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Only the dependencies having missing bounds are updated."
   , fromFile :: FilePath
fromFile        = FilePath
forall a. Default a => a
def FilePath -> Ann -> FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"FILE" FilePath -> Ann -> FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Update bounds by the library versions specified in the given file."
   , haskellPlatform :: FilePath
haskellPlatform = FilePath
forall a. Default a => a
def FilePath -> Ann -> FilePath
forall val. Data val => val -> Ann -> val
&= Ann
explicit FilePath -> Ann -> FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"VERSION" FilePath -> Ann -> FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"haskell-platform"
                           FilePath -> Ann -> FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Update bounds by the library versions of the specified haskell platform version"
   , setupConfigFile :: Maybe FilePath
setupConfigFile = Maybe FilePath
forall a. Default a => a
def Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= Ann
CmdArgs.ignore
   , planFile :: Maybe FilePath
planFile        = Maybe FilePath
forall a. Default a => a
def Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= Ann
CmdArgs.ignore
   }


dumpArgs :: Args
dumpArgs :: Args
dumpArgs = Dump
   { output :: Maybe FilePath
output     = Maybe FilePath
forall a. Default a => a
def Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= Ann
explicit Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"FILE" Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"output" Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"o"
                      Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Save libraries with lower bounds to file, if empty, then it's written to stdout."
   , cabalFiles :: [FilePath]
cabalFiles = [FilePath]
forall a. Default a => a
def [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= Ann
args [FilePath] -> Ann -> [FilePath]
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"CABAL-FILE"
   }


libsArgs :: Args
libsArgs :: Args
libsArgs = Libs
   { output :: Maybe FilePath
output          = Maybe FilePath
forall a. Default a => a
def Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= Ann
explicit Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"FILE" Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"output" Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"o"
                           Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Save the libraries cabal-bounds would use for its update run to file, if empty, then they're written to stdout."
   , fromFile :: FilePath
fromFile        = FilePath
forall a. Default a => a
def FilePath -> Ann -> FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"FILE" FilePath -> Ann -> FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Use the library versions specified in the given file."
   , haskellPlatform :: FilePath
haskellPlatform = FilePath
forall a. Default a => a
def FilePath -> Ann -> FilePath
forall val. Data val => val -> Ann -> val
&= Ann
explicit FilePath -> Ann -> FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"VERSION" FilePath -> Ann -> FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"haskell-platform"
                           FilePath -> Ann -> FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Use the library versions of the specified haskell platform version"
   }


formatArgs :: Args
formatArgs :: Args
formatArgs = Format
   { output :: Maybe FilePath
output    = Maybe FilePath
forall a. Default a => a
def Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= Ann
explicit Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
typ FilePath
"FILE" Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"output" Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
name FilePath
"o"
                     Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= FilePath -> Ann
help FilePath
"Save the formated cabal file to file, if empty, the cabal file is modified inplace."
   , cabalFile :: Maybe FilePath
cabalFile = Maybe FilePath
forall a. Default a => a
def Maybe FilePath -> Ann -> Maybe FilePath
forall val. Data val => val -> Ann -> val
&= Ann
CmdArgs.ignore
   }


versionInfo :: String
versionInfo :: FilePath
versionInfo =
#ifdef CABAL
   FilePath
"cabal-bounds version " FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++ Version -> FilePath
showVersion Version
version
#else
   "cabal-bounds version unknown (not built with cabal)"
#endif