{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE RecordWildCards     #-}
{-# LANGUAGE RankNTypes          #-}
{-# LANGUAGE DeriveGeneric       #-}
{-# LANGUAGE LambdaCase          #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  Distribution.Client.Setup
-- Copyright   :  (c) David Himmelstrup 2005
-- License     :  BSD-like
--
-- Maintainer  :  lemmih@gmail.com
-- Stability   :  provisional
-- Portability :  portable
--
--
-----------------------------------------------------------------------------
module Distribution.Client.Setup
    ( globalCommand, GlobalFlags(..), defaultGlobalFlags
    , RepoContext(..), withRepoContext
    , configureCommand, ConfigFlags(..), configureOptions, filterConfigureFlags
    , configPackageDB', configCompilerAux'
    , configureExCommand, ConfigExFlags(..), defaultConfigExFlags
    , buildCommand, BuildFlags(..)
    , filterTestFlags
    , replCommand, testCommand, benchmarkCommand, testOptions, benchmarkOptions
                        , configureExOptions, reconfigureCommand
    , installCommand, InstallFlags(..), installOptions, defaultInstallFlags
    , filterHaddockArgs, filterHaddockFlags, haddockOptions
    , defaultSolver, defaultMaxBackjumps
    , listCommand, ListFlags(..), listNeedsCompiler
    ,UpdateFlags(..), defaultUpdateFlags
    , infoCommand, InfoFlags(..)
    , fetchCommand, FetchFlags(..)
    , freezeCommand, FreezeFlags(..)
    , genBoundsCommand
    , getCommand, unpackCommand, GetFlags(..)
    , checkCommand
    , formatCommand
    , uploadCommand, UploadFlags(..), IsCandidate(..)
    , reportCommand, ReportFlags(..)
    , runCommand
    , initCommand, initOptions, IT.InitFlags(..)
    , actAsSetupCommand, ActAsSetupFlags(..)
    , userConfigCommand, UserConfigFlags(..)
    , manpageCommand
    , haddockCommand
    , cleanCommand
    , copyCommand
    , registerCommand

    , liftOptions
    , yesNoOpt
    ) where

import Prelude ()
import Distribution.Client.Compat.Prelude hiding (get)

import Distribution.Client.Types.Credentials (Username (..), Password (..))
import Distribution.Client.Types.Repo (RemoteRepo(..), LocalRepo (..))
import Distribution.Client.Types.AllowNewer (AllowNewer(..), AllowOlder(..), RelaxDeps(..))
import Distribution.Client.Types.WriteGhcEnvironmentFilesPolicy

import Distribution.Client.BuildReports.Types
         ( ReportLevel(..) )
import Distribution.Client.Dependency.Types
         ( PreSolver(..) )
import Distribution.Client.IndexUtils.ActiveRepos
         ( ActiveRepos )
import Distribution.Client.IndexUtils.IndexState
         ( TotalIndexState, headTotalIndexState )
import qualified Distribution.Client.Init.Types as IT
import qualified Distribution.Client.Init.Defaults as IT
import Distribution.Client.Targets
  ( UserConstraint
  , readUserConstraint
  )
import Distribution.Deprecated.ParseUtils (parseSpaceList, parseTokenQ)
import Distribution.Deprecated.ReadP (readP_to_E)
import Distribution.Utils.NubList
         ( NubList, toNubList, fromNubList)

import Distribution.Solver.Types.ConstraintSource
import Distribution.Solver.Types.Settings

import Distribution.Simple.Compiler ( Compiler, PackageDB, PackageDBStack )
import Distribution.Simple.Program (ProgramDb, defaultProgramDb)
import Distribution.Simple.Command hiding (boolOpt, boolOpt')
import qualified Distribution.Simple.Command as Command
import Distribution.Simple.Configure
       ( configCompilerAuxEx, interpretPackageDbFlags, computeEffectiveProfiling )
import qualified Distribution.Simple.Setup as Cabal
import Distribution.Simple.Flag
         ( Flag(..), toFlag, flagToMaybe, flagToList, maybeToFlag
         , flagElim, fromFlagOrDefault
         )
import Distribution.Simple.Setup
         ( ConfigFlags(..), BuildFlags(..), ReplFlags
         , TestFlags, BenchmarkFlags
         , HaddockFlags(..)
         , CleanFlags(..)
         , CopyFlags(..), RegisterFlags(..)
         , readPackageDbList, showPackageDbList
         , BooleanFlag(..), optionVerbosity
         , boolOpt, boolOpt', trueArg, falseArg
         , optionNumJobs )
import Distribution.Simple.InstallDirs
         ( PathTemplate, InstallDirs(..)
         , toPathTemplate, fromPathTemplate, combinePathTemplate )
import Distribution.Version
         ( Version, mkVersion )
import Distribution.Types.GivenComponent
         ( GivenComponent(..) )
import Distribution.Types.PackageVersionConstraint
         ( PackageVersionConstraint(..) )
import Distribution.Types.UnqualComponentName
         ( unqualComponentNameToPackageName )
import Distribution.PackageDescription
         ( BuildType(..), RepoKind(..), LibraryName(..), Dependency )
import Distribution.System ( Platform )
import Distribution.ReadE
         ( ReadE(..), succeedReadE, parsecToReadE, parsecToReadEErr, unexpectMsgString )
import qualified Distribution.Compat.CharParsing as P
import Distribution.Verbosity
         ( lessVerbose, normal, verboseNoFlags, verboseNoTimestamp )
import Distribution.Simple.Utils
         ( wrapText )
import Distribution.Client.GlobalFlags
         ( GlobalFlags(..), defaultGlobalFlags
         , RepoContext(..), withRepoContext
         )
import Distribution.Client.ManpageFlags (ManpageFlags, defaultManpageFlags, manpageOptions)
import Distribution.FieldGrammar.Newtypes (SpecVersion (..))
import Distribution.Parsec
         ( parsecCommaList  )

import Data.List
         ( deleteFirstsBy )
import System.FilePath
         ( (</>) )

globalCommand :: [Command action] -> CommandUI GlobalFlags
globalCommand :: forall action. [Command action] -> CommandUI GlobalFlags
globalCommand [Command action]
commands = CommandUI {
    commandName :: String
commandName         = String
"",
    commandSynopsis :: String
commandSynopsis     =
         String
"Command line interface to the Haskell Cabal infrastructure.",
    commandUsage :: String -> String
commandUsage        = \String
pname ->
         String
"See http://www.haskell.org/cabal/ for more information.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"Usage: " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" [GLOBAL FLAGS] [COMMAND [FLAGS]]\n",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname ->
      let
        commands' :: [Command action]
commands' = [Command action]
commands forall a. [a] -> [a] -> [a]
++ [forall flags action.
CommandUI flags -> (flags -> [String] -> action) -> Command action
commandAddAction CommandUI ()
helpCommandUI forall a. HasCallStack => a
undefined]
        cmdDescs :: [(String, String)]
cmdDescs = forall action. [Command action] -> [(String, String)]
getNormalCommandDescriptions [Command action]
commands'
        -- if new commands are added, we want them to appear even if they
        -- are not included in the custom listing below. Thus, we calculate
        -- the `otherCmds` list and append it under the `other` category.
        -- Alternatively, a new testcase could be added that ensures that
        -- the set of commands listed here is equal to the set of commands
        -- that are actually available.
        otherCmds :: [String]
otherCmds = forall a. (a -> a -> Bool) -> [a] -> [a] -> [a]
deleteFirstsBy forall a. Eq a => a -> a -> Bool
(==) (forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst [(String, String)]
cmdDescs)
          [ String
"help"
          , String
"update"
          , String
"install"
          , String
"fetch"
          , String
"list"
          , String
"info"
          , String
"user-config"
          , String
"get"
          , String
"unpack"
          , String
"init"
          , String
"configure"
          , String
"build"
          , String
"clean"
          , String
"run"
          , String
"repl"
          , String
"test"
          , String
"bench"
          , String
"check"
          , String
"sdist"
          , String
"upload"
          , String
"report"
          , String
"freeze"
          , String
"gen-bounds"
          , String
"outdated"
          , String
"haddock"
          , String
"hscolour"
          , String
"exec"
          , String
"new-build"
          , String
"new-configure"
          , String
"new-repl"
          , String
"new-freeze"
          , String
"new-run"
          , String
"new-test"
          , String
"new-bench"
          , String
"new-haddock"
          , String
"new-exec"
          , String
"new-update"
          , String
"new-install"
          , String
"new-clean"
          , String
"new-sdist"
          , String
"list-bin"
          -- v1 commands, stateful style
          , String
"v1-build"
          , String
"v1-configure"
          , String
"v1-repl"
          , String
"v1-freeze"
          , String
"v1-run"
          , String
"v1-test"
          , String
"v1-bench"
          , String
"v1-haddock"
          , String
"v1-exec"
          , String
"v1-update"
          , String
"v1-install"
          , String
"v1-clean"
          , String
"v1-sdist"
          , String
"v1-doctest"
          , String
"v1-copy"
          , String
"v1-register"
          , String
"v1-reconfigure"
          -- v2 commands, nix-style
          , String
"v2-build"
          , String
"v2-configure"
          , String
"v2-repl"
          , String
"v2-freeze"
          , String
"v2-run"
          , String
"v2-test"
          , String
"v2-bench"
          , String
"v2-haddock"
          , String
"v2-exec"
          , String
"v2-update"
          , String
"v2-install"
          , String
"v2-clean"
          , String
"v2-sdist"
          ]
        maxlen :: Int
maxlen    = forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum forall a b. (a -> b) -> a -> b
$ [forall (t :: * -> *) a. Foldable t => t a -> Int
length String
name | (String
name, String
_) <- [(String, String)]
cmdDescs]
        align :: String -> String
align String
str = String
str forall a. [a] -> [a] -> [a]
++ forall a. Int -> a -> [a]
replicate (Int
maxlen forall a. Num a => a -> a -> a
- forall (t :: * -> *) a. Foldable t => t a -> Int
length String
str) Char
' '
        startGroup :: String -> String
startGroup String
n = String
" ["forall a. [a] -> [a] -> [a]
++String
nforall a. [a] -> [a] -> [a]
++String
"]"
        par :: String
par          = String
""
        addCmd :: String -> String
addCmd String
n     = case forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup String
n [(String, String)]
cmdDescs of
                         Maybe String
Nothing -> String
""
                         Just String
d -> String
"  " forall a. [a] -> [a] -> [a]
++ String -> String
align String
n forall a. [a] -> [a] -> [a]
++ String
"    " forall a. [a] -> [a] -> [a]
++ String
d
      in
         String
"Commands:\n"
      forall a. [a] -> [a] -> [a]
++ [String] -> String
unlines (
        [ String -> String
startGroup String
"global"
        , String -> String
addCmd String
"user-config"
        , String -> String
addCmd String
"help"
        , String
par
        , String -> String
startGroup String
"package database"
        , String -> String
addCmd String
"update"
        , String -> String
addCmd String
"list"
        , String -> String
addCmd String
"info"
        , String
par
        , String -> String
startGroup String
"initialization and download"
        , String -> String
addCmd String
"init"
        , String -> String
addCmd String
"fetch"
        , String -> String
addCmd String
"get"
        , String
par
        , String -> String
startGroup String
"project configuration"
        , String -> String
addCmd String
"configure"
        , String -> String
addCmd String
"freeze"
        , String -> String
addCmd String
"gen-bounds"
        , String -> String
addCmd String
"outdated"
        , String
par
        , String -> String
startGroup String
"project building and installing"
        , String -> String
addCmd String
"build"
        , String -> String
addCmd String
"install"
        , String -> String
addCmd String
"haddock"
        , String -> String
addCmd String
"haddock-project"
        , String -> String
addCmd String
"clean"
        , String
par
        , String -> String
startGroup String
"running and testing"
        , String -> String
addCmd String
"list-bin"
        , String -> String
addCmd String
"repl"
        , String -> String
addCmd String
"run"
        , String -> String
addCmd String
"bench"
        , String -> String
addCmd String
"test"
        , String -> String
addCmd String
"exec"
        , String
par
        , String -> String
startGroup String
"sanity checks and shipping"
        , String -> String
addCmd String
"check"
        , String -> String
addCmd String
"sdist"
        , String -> String
addCmd String
"upload"
        , String -> String
addCmd String
"report"
        , String
par
        , String -> String
startGroup String
"deprecated"
        , String -> String
addCmd String
"unpack"
        , String -> String
addCmd String
"hscolour"
        , String
par
        , String -> String
startGroup String
"new-style projects (forwards-compatible aliases)"
        , String -> String
addCmd String
"v2-build"
        , String -> String
addCmd String
"v2-configure"
        , String -> String
addCmd String
"v2-repl"
        , String -> String
addCmd String
"v2-run"
        , String -> String
addCmd String
"v2-test"
        , String -> String
addCmd String
"v2-bench"
        , String -> String
addCmd String
"v2-freeze"
        , String -> String
addCmd String
"v2-haddock"
        , String -> String
addCmd String
"v2-exec"
        , String -> String
addCmd String
"v2-update"
        , String -> String
addCmd String
"v2-install"
        , String -> String
addCmd String
"v2-clean"
        , String -> String
addCmd String
"v2-sdist"
        , String
par
        , String -> String
startGroup String
"legacy command aliases"
        , String -> String
addCmd String
"v1-build"
        , String -> String
addCmd String
"v1-configure"
        , String -> String
addCmd String
"v1-repl"
        , String -> String
addCmd String
"v1-run"
        , String -> String
addCmd String
"v1-test"
        , String -> String
addCmd String
"v1-bench"
        , String -> String
addCmd String
"v1-freeze"
        , String -> String
addCmd String
"v1-haddock"
        , String -> String
addCmd String
"v1-install"
        , String -> String
addCmd String
"v1-clean"
        , String -> String
addCmd String
"v1-copy"
        , String -> String
addCmd String
"v1-register"
        , String -> String
addCmd String
"v1-reconfigure"
        ] forall a. [a] -> [a] -> [a]
++ if forall (t :: * -> *) a. Foldable t => t a -> Bool
null [String]
otherCmds then [] else String
par
                                           forall a. a -> [a] -> [a]
:String -> String
startGroup String
"other"
                                           forall a. a -> [a] -> [a]
:[String -> String
addCmd String
n | String
n <- [String]
otherCmds])
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"For more information about a command use:\n"
      forall a. [a] -> [a] -> [a]
++ String
"   " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" COMMAND --help\n"
      forall a. [a] -> [a] -> [a]
++ String
"or " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" help COMMAND\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"To install Cabal packages from hackage use:\n"
      forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" install foo [--dry-run]\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"Occasionally you need to update the list of available packages:\n"
      forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" update\n",
    commandNotes :: Maybe (String -> String)
commandNotes = forall a. Maybe a
Nothing,
    commandDefaultFlags :: GlobalFlags
commandDefaultFlags = forall a. Monoid a => a
mempty,
    commandOptions :: ShowOrParseArgs -> [OptionField GlobalFlags]
commandOptions = ShowOrParseArgs -> [OptionField GlobalFlags]
args
  }
  where
    args :: ShowOrParseArgs -> [OptionField GlobalFlags]
    args :: ShowOrParseArgs -> [OptionField GlobalFlags]
args ShowOrParseArgs
ShowArgs  = [OptionField GlobalFlags]
argsShown
    args ShowOrParseArgs
ParseArgs = [OptionField GlobalFlags]
argsShown forall a. [a] -> [a] -> [a]
++ [OptionField GlobalFlags]
argsNotShown

    -- arguments we want to show in the help
    argsShown :: [OptionField GlobalFlags]
    argsShown :: [OptionField GlobalFlags]
argsShown = [
       forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'V'] [String
"version"]
         String
"Print version information"
         GlobalFlags -> Flag Bool
globalVersion (\Flag Bool
v GlobalFlags
flags -> GlobalFlags
flags { globalVersion :: Flag Bool
globalVersion = Flag Bool
v })
         forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

      ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"numeric-version"]
         String
"Print just the version number"
         GlobalFlags -> Flag Bool
globalNumericVersion (\Flag Bool
v GlobalFlags
flags -> GlobalFlags
flags { globalNumericVersion :: Flag Bool
globalNumericVersion = Flag Bool
v })
         forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

      ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"config-file"]
         String
"Set an alternate location for the config file"
         GlobalFlags -> Flag String
globalConfigFile (\Flag String
v GlobalFlags
flags -> GlobalFlags
flags { globalConfigFile :: Flag String
globalConfigFile = Flag String
v })
         (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"FILE")

      ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"ignore-expiry"]
         String
"Ignore expiry dates on signed metadata (use only in exceptional circumstances)"
         GlobalFlags -> Flag Bool
globalIgnoreExpiry (\Flag Bool
v GlobalFlags
flags -> GlobalFlags
flags { globalIgnoreExpiry :: Flag Bool
globalIgnoreExpiry = Flag Bool
v })
         forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

      ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"http-transport"]
         String
"Set a transport for http(s) requests. Accepts 'curl', 'wget', 'powershell', and 'plain-http'. (default: 'curl')"
         GlobalFlags -> Flag String
globalHttpTransport (\Flag String
v GlobalFlags
flags -> GlobalFlags
flags { globalHttpTransport :: Flag String
globalHttpTransport = Flag String
v })
         (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"HttpTransport")

      ,forall get set a.
String -> get -> set -> [get -> set -> OptDescr a] -> OptionField a
multiOption String
"nix"
        GlobalFlags -> Flag Bool
globalNix (\Flag Bool
v GlobalFlags
flags -> GlobalFlags
flags { globalNix :: Flag Bool
globalNix = Flag Bool
v })
        [
          forall b a.
Monoid b =>
String
-> (Maybe String -> b)
-> (b -> [Maybe String])
-> MkOptDescr (a -> b) (b -> a -> a) a
optArg' String
"(True or False)" (forall a. Maybe a -> Flag a
maybeToFlag forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Read a => String -> Maybe a
readMaybe forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<)) (\case
            Flag Bool
True -> [forall a. a -> Maybe a
Just String
"enable"]
            Flag Bool
False -> [forall a. a -> Maybe a
Just String
"disable"]
            Flag Bool
NoFlag -> []) String
"" [String
"nix"] -- Must be empty because we need to return PP.empty from viewAsFieldDescr
            String
"Nix integration: run commands through nix-shell if a 'shell.nix' file exists (default is False)",
          forall b a. Eq b => b -> MkOptDescr (a -> b) (b -> a -> a) a
noArg (forall a. a -> Flag a
Flag Bool
True) [] [String
"enable-nix"]
          String
"Enable Nix integration: run commands through nix-shell if a 'shell.nix' file exists",
          forall b a. Eq b => b -> MkOptDescr (a -> b) (b -> a -> a) a
noArg (forall a. a -> Flag a
Flag Bool
False) [] [String
"disable-nix"]
          String
"Disable Nix integration"
        ]

      ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"store-dir", String
"storedir"]
         String
"The location of the build store"
         GlobalFlags -> Flag String
globalStoreDir (\Flag String
v GlobalFlags
flags -> GlobalFlags
flags { globalStoreDir :: Flag String
globalStoreDir = Flag String
v })
         (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"DIR")

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"active-repositories"]
         String
"The active package repositories (set to ':none' to disable all repositories)"
         GlobalFlags -> Flag ActiveRepos
globalActiveRepos (\Flag ActiveRepos
v GlobalFlags
flags ->  GlobalFlags
flags { globalActiveRepos :: Flag ActiveRepos
globalActiveRepos = Flag ActiveRepos
v })
         (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"REPOS" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (\String
err -> String
"Error parsing active-repositories: " forall a. [a] -> [a] -> [a]
++ String
err)
                                        (forall a. a -> Flag a
toFlag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                         (forall a b. (a -> b) -> [a] -> [b]
map forall a. Pretty a => a -> String
prettyShow forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Flag a -> [a]
flagToList))
      ]

    -- arguments we don't want shown in the help
    -- the remote repo flags are not useful compared to the more general "active-repositories" flag.
    -- the global logs directory was only used in v1, while in v2 we have specific project config logs dirs
    -- default-user-config is support for a relatively obscure workflow for v1-freeze.
    argsNotShown :: [OptionField GlobalFlags]
    argsNotShown :: [OptionField GlobalFlags]
argsNotShown = [
       forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"remote-repo"]
         String
"The name and url for a remote repository"
         GlobalFlags -> NubList RemoteRepo
globalRemoteRepos (\NubList RemoteRepo
v GlobalFlags
flags -> GlobalFlags
flags { globalRemoteRepos :: NubList RemoteRepo
globalRemoteRepos = NubList RemoteRepo
v })
         (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"NAME:URL" (forall a. Ord a => [a] -> NubList a
toNubList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Maybe a -> [a]
maybeToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Maybe RemoteRepo
readRemoteRepo) (forall a b. (a -> b) -> [a] -> [b]
map RemoteRepo -> String
showRemoteRepo forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NubList a -> [a]
fromNubList))

      ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"local-no-index-repo"]
         String
"The name and a path for a local no-index repository"
         GlobalFlags -> NubList LocalRepo
globalLocalNoIndexRepos (\NubList LocalRepo
v GlobalFlags
flags -> GlobalFlags
flags { globalLocalNoIndexRepos :: NubList LocalRepo
globalLocalNoIndexRepos = NubList LocalRepo
v })
         (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"NAME:PATH" (forall a. Ord a => [a] -> NubList a
toNubList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Maybe a -> [a]
maybeToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Maybe LocalRepo
readLocalRepo) (forall a b. (a -> b) -> [a] -> [b]
map LocalRepo -> String
showLocalRepo forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NubList a -> [a]
fromNubList))

      ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"remote-repo-cache"]
         String
"The location where downloads from all remote repos are cached"
         GlobalFlags -> Flag String
globalCacheDir (\Flag String
v GlobalFlags
flags -> GlobalFlags
flags { globalCacheDir :: Flag String
globalCacheDir = Flag String
v })
         (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"DIR")

      ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"logs-dir", String
"logsdir"]
         String
"The location to put log files"
         GlobalFlags -> Flag String
globalLogsDir (\Flag String
v GlobalFlags
flags -> GlobalFlags
flags { globalLogsDir :: Flag String
globalLogsDir = Flag String
v })
         (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"DIR")

      ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"default-user-config"]
         String
"Set a location for a cabal.config file for projects without their own cabal.config freeze file."
         GlobalFlags -> Flag String
globalConstraintsFile (\Flag String
v GlobalFlags
flags -> GlobalFlags
flags {globalConstraintsFile :: Flag String
globalConstraintsFile = Flag String
v})
         (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"FILE")
      ]

-- ------------------------------------------------------------
-- * Config flags
-- ------------------------------------------------------------

configureCommand :: CommandUI ConfigFlags
configureCommand :: CommandUI ConfigFlags
configureCommand = CommandUI ConfigFlags
c
  { commandName :: String
commandName         = String
"configure"
  , commandDefaultFlags :: ConfigFlags
commandDefaultFlags = forall a. Monoid a => a
mempty
  , commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
         String
"Configure how the package is built by setting "
      forall a. [a] -> [a] -> [a]
++ String
"package (and other) flags.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"The configuration affects several other commands, "
      forall a. [a] -> [a] -> [a]
++ String
"including v1-build, v1-test, v1-bench, v1-run, v1-repl.\n"
  , commandUsage :: String -> String
commandUsage        = \String
pname ->
    String
"Usage: " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-configure [FLAGS]\n"
  , commandNotes :: Maybe (String -> String)
commandNotes = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname ->
    (ProgramDb -> String
Cabal.programFlagsDescription ProgramDb
defaultProgramDb forall a. [a] -> [a] -> [a]
++ String
"\n")
      forall a. [a] -> [a] -> [a]
++ String
"Examples:\n"
      forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-configure\n"
      forall a. [a] -> [a] -> [a]
++ String
"    Configure with defaults;\n"
      forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-configure --enable-tests -fcustomflag\n"
      forall a. [a] -> [a] -> [a]
++ String
"    Configure building package including tests,\n"
      forall a. [a] -> [a] -> [a]
++ String
"    with some package-specific flag.\n"
  }
 where
  c :: CommandUI ConfigFlags
c = ProgramDb -> CommandUI ConfigFlags
Cabal.configureCommand ProgramDb
defaultProgramDb

configureOptions ::  ShowOrParseArgs -> [OptionField ConfigFlags]
configureOptions :: ShowOrParseArgs -> [OptionField ConfigFlags]
configureOptions = forall flags.
CommandUI flags -> ShowOrParseArgs -> [OptionField flags]
commandOptions CommandUI ConfigFlags
configureCommand

-- | Given some 'ConfigFlags' for the version of Cabal that
-- cabal-install was built with, and a target older 'Version' of
-- Cabal that we want to pass these flags to, convert the
-- flags into a form that will be accepted by the older
-- Setup script.  Generally speaking, this just means filtering
-- out flags that the old Cabal library doesn't understand, but
-- in some cases it may also mean "emulating" a feature using
-- some more legacy flags.
filterConfigureFlags :: ConfigFlags -> Version -> ConfigFlags
filterConfigureFlags :: ConfigFlags -> Version -> ConfigFlags
filterConfigureFlags ConfigFlags
flags Version
cabalLibVersion
  -- NB: we expect the latest version to be the most common case,
  -- so test it first.
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
3,Int
7,Int
0]  = ConfigFlags
flags_latest
  -- The naming convention is that flags_version gives flags with
  -- all flags *introduced* in version eliminated.
  -- It is NOT the latest version of Cabal library that
  -- these flags work for; version of introduction is a more
  -- natural metric.
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
1,Int
3,Int
10] = ConfigFlags
flags_1_3_10
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
1,Int
10,Int
0] = ConfigFlags
flags_1_10_0
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
1,Int
12,Int
0] = ConfigFlags
flags_1_12_0
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
1,Int
14,Int
0] = ConfigFlags
flags_1_14_0
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
1,Int
18,Int
0] = ConfigFlags
flags_1_18_0
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
1,Int
19,Int
1] = ConfigFlags
flags_1_19_1
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
1,Int
19,Int
2] = ConfigFlags
flags_1_19_2
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
1,Int
21,Int
1] = ConfigFlags
flags_1_21_1
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
1,Int
22,Int
0] = ConfigFlags
flags_1_22_0
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
1,Int
22,Int
1] = ConfigFlags
flags_1_22_1
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
1,Int
23,Int
0] = ConfigFlags
flags_1_23_0
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
1,Int
25,Int
0] = ConfigFlags
flags_1_25_0
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
2,Int
1,Int
0]  = ConfigFlags
flags_2_1_0
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
2,Int
5,Int
0]  = ConfigFlags
flags_2_5_0
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
3,Int
7,Int
0]  = ConfigFlags
flags_3_7_0
  | Bool
otherwise = forall a. HasCallStack => String -> a
error String
"the impossible just happened" -- see first guard
  where
    flags_latest :: ConfigFlags
flags_latest = ConfigFlags
flags        {
      -- Cabal >= 1.19.1 uses '--dependency' and does not need '--constraint'.
      -- Note: this is not in the wrong place. configConstraints gets
      -- repopulated in flags_1_19_1 but it needs to be set to empty for
      -- newer versions first.
      configConstraints :: [PackageVersionConstraint]
configConstraints = []
      }

    flags_3_7_0 :: ConfigFlags
flags_3_7_0 = ConfigFlags
flags_latest {
        -- Cabal < 3.7 does not know about --extra-lib-dirs-static
        configExtraLibDirsStatic :: [String]
configExtraLibDirsStatic = [],

        -- Cabal < 3.7 does not understand '--enable-build-info' or '--disable-build-info'
        configDumpBuildInfo :: Flag DumpBuildInfo
configDumpBuildInfo = forall a. Flag a
NoFlag
      }

    flags_2_5_0 :: ConfigFlags
flags_2_5_0 = ConfigFlags
flags_3_7_0 {
      -- Cabal < 2.5 does not understand --dependency=pkg:component=cid
      -- (public sublibraries), so we convert it to the legacy
      -- --dependency=pkg_or_internal_component=cid
        configDependencies :: [GivenComponent]
configDependencies =
          let convertToLegacyInternalDep :: GivenComponent -> Maybe GivenComponent
convertToLegacyInternalDep (GivenComponent PackageName
_ (LSubLibName UnqualComponentName
cn) ComponentId
cid) =
                forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ PackageName -> LibraryName -> ComponentId -> GivenComponent
GivenComponent
                       (UnqualComponentName -> PackageName
unqualComponentNameToPackageName UnqualComponentName
cn)
                       LibraryName
LMainLibName
                       ComponentId
cid
              convertToLegacyInternalDep (GivenComponent PackageName
pn LibraryName
LMainLibName ComponentId
cid) =
                forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ PackageName -> LibraryName -> ComponentId -> GivenComponent
GivenComponent PackageName
pn LibraryName
LMainLibName ComponentId
cid
          in forall a. [Maybe a] -> [a]
catMaybes forall a b. (a -> b) -> a -> b
$ GivenComponent -> Maybe GivenComponent
convertToLegacyInternalDep forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ConfigFlags -> [GivenComponent]
configDependencies ConfigFlags
flags
        -- Cabal < 2.5 doesn't know about '--allow-depending-on-private-libs'.
      , configAllowDependingOnPrivateLibs :: Flag Bool
configAllowDependingOnPrivateLibs = forall a. Flag a
NoFlag
        -- Cabal < 2.5 doesn't know about '--enable/disable-executable-static'.
      , configFullyStaticExe :: Flag Bool
configFullyStaticExe = forall a. Flag a
NoFlag
      }

    flags_2_1_0 :: ConfigFlags
flags_2_1_0 = ConfigFlags
flags_2_5_0 {
      -- Cabal < 2.1 doesn't know about -v +timestamp modifier
        configVerbosity :: Flag Verbosity
configVerbosity   = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Verbosity -> Verbosity
verboseNoTimestamp (ConfigFlags -> Flag Verbosity
configVerbosity ConfigFlags
flags_latest)
      -- Cabal < 2.1 doesn't know about --<enable|disable>-static
      , configStaticLib :: Flag Bool
configStaticLib   = forall a. Flag a
NoFlag
      , configSplitSections :: Flag Bool
configSplitSections = forall a. Flag a
NoFlag
      }

    flags_1_25_0 :: ConfigFlags
flags_1_25_0 = ConfigFlags
flags_2_1_0 {
      -- Cabal < 1.25.0 doesn't know about --dynlibdir.
      configInstallDirs :: InstallDirs (Flag PathTemplate)
configInstallDirs = InstallDirs (Flag PathTemplate)
configInstallDirs_1_25_0,
      -- Cabal < 1.25 doesn't have extended verbosity syntax
      configVerbosity :: Flag Verbosity
configVerbosity   = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Verbosity -> Verbosity
verboseNoFlags (ConfigFlags -> Flag Verbosity
configVerbosity ConfigFlags
flags_2_1_0),
      -- Cabal < 1.25 doesn't support --deterministic
      configDeterministic :: Flag Bool
configDeterministic = forall a. Monoid a => a
mempty
      }
    configInstallDirs_1_25_0 :: InstallDirs (Flag PathTemplate)
configInstallDirs_1_25_0 = let dirs :: InstallDirs (Flag PathTemplate)
dirs = ConfigFlags -> InstallDirs (Flag PathTemplate)
configInstallDirs ConfigFlags
flags in
        InstallDirs (Flag PathTemplate)
dirs { dynlibdir :: Flag PathTemplate
dynlibdir = forall a. Flag a
NoFlag
             , libexecsubdir :: Flag PathTemplate
libexecsubdir = forall a. Flag a
NoFlag
             , libexecdir :: Flag PathTemplate
libexecdir = forall a. Maybe a -> Flag a
maybeToFlag forall a b. (a -> b) -> a -> b
$
                 PathTemplate -> PathTemplate -> PathTemplate
combinePathTemplate forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Flag a -> Maybe a
flagToMaybe (forall dir. InstallDirs dir -> dir
libexecdir InstallDirs (Flag PathTemplate)
dirs)
                                     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Flag a -> Maybe a
flagToMaybe (forall dir. InstallDirs dir -> dir
libexecsubdir InstallDirs (Flag PathTemplate)
dirs)
             }
    -- Cabal < 1.23 doesn't know about '--profiling-detail'.
    -- Cabal < 1.23 has a hacked up version of 'enable-profiling'
    -- which we shouldn't use.
    (Bool
tryLibProfiling, Bool
tryExeProfiling) = ConfigFlags -> (Bool, Bool)
computeEffectiveProfiling ConfigFlags
flags
    flags_1_23_0 :: ConfigFlags
flags_1_23_0 = ConfigFlags
flags_1_25_0 { configProfDetail :: Flag ProfDetailLevel
configProfDetail    = forall a. Flag a
NoFlag
                                , configProfLibDetail :: Flag ProfDetailLevel
configProfLibDetail = forall a. Flag a
NoFlag
                                , configIPID :: Flag String
configIPID          = forall a. Flag a
NoFlag
                                , configProf :: Flag Bool
configProf          = forall a. Flag a
NoFlag
                                , configProfExe :: Flag Bool
configProfExe       = forall a. a -> Flag a
Flag Bool
tryExeProfiling
                                , configProfLib :: Flag Bool
configProfLib       = forall a. a -> Flag a
Flag Bool
tryLibProfiling
                                }

    -- Cabal == 1.22.0.* had a discontinuity (see #5946 or e9a8d48a3adce34d)
    -- due to temporary amnesia of the --*-executable-profiling flags
    flags_1_22_1 :: ConfigFlags
flags_1_22_1 = ConfigFlags
flags_1_23_0 { configDebugInfo :: Flag DebugInfoLevel
configDebugInfo = forall a. Flag a
NoFlag
                                , configProfExe :: Flag Bool
configProfExe   = forall a. Flag a
NoFlag
                                }

    -- Cabal < 1.22 doesn't know about '--disable-debug-info'.
    flags_1_22_0 :: ConfigFlags
flags_1_22_0 = ConfigFlags
flags_1_23_0 { configDebugInfo :: Flag DebugInfoLevel
configDebugInfo = forall a. Flag a
NoFlag }

    -- Cabal < 1.21.1 doesn't know about 'disable-relocatable'
    -- Cabal < 1.21.1 doesn't know about 'enable-profiling'
    -- (but we already dealt with it in flags_1_23_0)
    flags_1_21_1 :: ConfigFlags
flags_1_21_1 =
      ConfigFlags
flags_1_22_0 { configRelocatable :: Flag Bool
configRelocatable = forall a. Flag a
NoFlag
                   , configCoverage :: Flag Bool
configCoverage = forall a. Flag a
NoFlag
                   , configLibCoverage :: Flag Bool
configLibCoverage = ConfigFlags -> Flag Bool
configCoverage ConfigFlags
flags
                   }
    -- Cabal < 1.19.2 doesn't know about '--exact-configuration' and
    -- '--enable-library-stripping'.
    flags_1_19_2 :: ConfigFlags
flags_1_19_2 = ConfigFlags
flags_1_21_1 { configExactConfiguration :: Flag Bool
configExactConfiguration = forall a. Flag a
NoFlag
                                , configStripLibs :: Flag Bool
configStripLibs = forall a. Flag a
NoFlag }
    -- Cabal < 1.19.1 uses '--constraint' instead of '--dependency'.
    flags_1_19_1 :: ConfigFlags
flags_1_19_1 = ConfigFlags
flags_1_19_2 { configDependencies :: [GivenComponent]
configDependencies = []
                                , configConstraints :: [PackageVersionConstraint]
configConstraints  = ConfigFlags -> [PackageVersionConstraint]
configConstraints ConfigFlags
flags }
    -- Cabal < 1.18.0 doesn't know about --extra-prog-path and --sysconfdir.
    flags_1_18_0 :: ConfigFlags
flags_1_18_0 = ConfigFlags
flags_1_19_1 { configProgramPathExtra :: NubList String
configProgramPathExtra = forall a. Ord a => [a] -> NubList a
toNubList []
                                , configInstallDirs :: InstallDirs (Flag PathTemplate)
configInstallDirs = InstallDirs (Flag PathTemplate)
configInstallDirs_1_18_0}
    configInstallDirs_1_18_0 :: InstallDirs (Flag PathTemplate)
configInstallDirs_1_18_0 = (ConfigFlags -> InstallDirs (Flag PathTemplate)
configInstallDirs ConfigFlags
flags_1_19_1) { sysconfdir :: Flag PathTemplate
sysconfdir = forall a. Flag a
NoFlag }
    -- Cabal < 1.14.0 doesn't know about '--disable-benchmarks'.
    flags_1_14_0 :: ConfigFlags
flags_1_14_0 = ConfigFlags
flags_1_18_0 { configBenchmarks :: Flag Bool
configBenchmarks  = forall a. Flag a
NoFlag }
    -- Cabal < 1.12.0 doesn't know about '--enable/disable-executable-dynamic'
    -- and '--enable/disable-library-coverage'.
    flags_1_12_0 :: ConfigFlags
flags_1_12_0 = ConfigFlags
flags_1_14_0 { configLibCoverage :: Flag Bool
configLibCoverage = forall a. Flag a
NoFlag
                                , configDynExe :: Flag Bool
configDynExe      = forall a. Flag a
NoFlag }
    -- Cabal < 1.10.0 doesn't know about '--disable-tests'.
    flags_1_10_0 :: ConfigFlags
flags_1_10_0 = ConfigFlags
flags_1_12_0 { configTests :: Flag Bool
configTests       = forall a. Flag a
NoFlag }
    -- Cabal < 1.3.10 does not grok the '--constraints' flag.
    flags_1_3_10 :: ConfigFlags
flags_1_3_10 = ConfigFlags
flags_1_10_0 { configConstraints :: [PackageVersionConstraint]
configConstraints = [] }

-- | Get the package database settings from 'ConfigFlags', accounting for
-- @--package-db@ and @--user@ flags.
configPackageDB' :: ConfigFlags -> PackageDBStack
configPackageDB' :: ConfigFlags -> PackageDBStack
configPackageDB' ConfigFlags
cfg =
    Bool -> [Maybe PackageDB] -> PackageDBStack
interpretPackageDbFlags Bool
userInstall (ConfigFlags -> [Maybe PackageDB]
configPackageDBs ConfigFlags
cfg)
  where
    userInstall :: Bool
userInstall = forall a. a -> Flag a -> a
Cabal.fromFlagOrDefault Bool
True (ConfigFlags -> Flag Bool
configUserInstall ConfigFlags
cfg)

-- | Configure the compiler, but reduce verbosity during this step.
configCompilerAux' :: ConfigFlags -> IO (Compiler, Platform, ProgramDb)
configCompilerAux' :: ConfigFlags -> IO (Compiler, Platform, ProgramDb)
configCompilerAux' ConfigFlags
configFlags =
  ConfigFlags -> IO (Compiler, Platform, ProgramDb)
configCompilerAuxEx ConfigFlags
configFlags
    --FIXME: make configCompilerAux use a sensible verbosity
    { configVerbosity :: Flag Verbosity
configVerbosity = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Verbosity -> Verbosity
lessVerbose (ConfigFlags -> Flag Verbosity
configVerbosity ConfigFlags
configFlags) }

-- ------------------------------------------------------------
-- * Config extra flags
-- ------------------------------------------------------------

-- | cabal configure takes some extra flags beyond runghc Setup configure
--
data ConfigExFlags = ConfigExFlags {
    ConfigExFlags -> Flag Version
configCabalVersion  :: Flag Version,
    ConfigExFlags -> Flag Bool
configAppend        :: Flag Bool,
    ConfigExFlags -> Flag Bool
configBackup        :: Flag Bool,
    ConfigExFlags -> [(UserConstraint, ConstraintSource)]
configExConstraints :: [(UserConstraint, ConstraintSource)],
    ConfigExFlags -> [PackageVersionConstraint]
configPreferences   :: [PackageVersionConstraint],
    ConfigExFlags -> Flag PreSolver
configSolver        :: Flag PreSolver,
    ConfigExFlags -> Maybe AllowNewer
configAllowNewer    :: Maybe AllowNewer,
    ConfigExFlags -> Maybe AllowOlder
configAllowOlder    :: Maybe AllowOlder,
    ConfigExFlags -> Flag WriteGhcEnvironmentFilesPolicy
configWriteGhcEnvironmentFilesPolicy
      :: Flag WriteGhcEnvironmentFilesPolicy
  }
  deriving (ConfigExFlags -> ConfigExFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConfigExFlags -> ConfigExFlags -> Bool
$c/= :: ConfigExFlags -> ConfigExFlags -> Bool
== :: ConfigExFlags -> ConfigExFlags -> Bool
$c== :: ConfigExFlags -> ConfigExFlags -> Bool
Eq, Int -> ConfigExFlags -> String -> String
[ConfigExFlags] -> String -> String
ConfigExFlags -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [ConfigExFlags] -> String -> String
$cshowList :: [ConfigExFlags] -> String -> String
show :: ConfigExFlags -> String
$cshow :: ConfigExFlags -> String
showsPrec :: Int -> ConfigExFlags -> String -> String
$cshowsPrec :: Int -> ConfigExFlags -> String -> String
Show, forall x. Rep ConfigExFlags x -> ConfigExFlags
forall x. ConfigExFlags -> Rep ConfigExFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ConfigExFlags x -> ConfigExFlags
$cfrom :: forall x. ConfigExFlags -> Rep ConfigExFlags x
Generic)

defaultConfigExFlags :: ConfigExFlags
defaultConfigExFlags :: ConfigExFlags
defaultConfigExFlags = forall a. Monoid a => a
mempty { configSolver :: Flag PreSolver
configSolver     = forall a. a -> Flag a
Flag PreSolver
defaultSolver }

configureExCommand :: CommandUI (ConfigFlags, ConfigExFlags)
configureExCommand :: CommandUI (ConfigFlags, ConfigExFlags)
configureExCommand = CommandUI ConfigFlags
configureCommand {
    commandDefaultFlags :: (ConfigFlags, ConfigExFlags)
commandDefaultFlags = (forall a. Monoid a => a
mempty, ConfigExFlags
defaultConfigExFlags),
    commandOptions :: ShowOrParseArgs -> [OptionField (ConfigFlags, ConfigExFlags)]
commandOptions      = \ShowOrParseArgs
showOrParseArgs ->
         forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions forall a b. (a, b) -> a
fst forall {a} {a} {b}. a -> (a, b) -> (a, b)
setFst
         (forall a. (a -> Bool) -> [a] -> [a]
filter ((forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [String
"constraint", String
"dependency", String
"exact-configuration"])
                  forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. OptionField a -> String
optionName) forall a b. (a -> b) -> a -> b
$ ShowOrParseArgs -> [OptionField ConfigFlags]
configureOptions  ShowOrParseArgs
showOrParseArgs)
      forall a. [a] -> [a] -> [a]
++ forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions forall a b. (a, b) -> b
snd forall {b} {a} {b}. b -> (a, b) -> (a, b)
setSnd
         (ShowOrParseArgs -> ConstraintSource -> [OptionField ConfigExFlags]
configureExOptions ShowOrParseArgs
showOrParseArgs ConstraintSource
ConstraintSourceCommandlineFlag)
  }
  where
    setFst :: a -> (a, b) -> (a, b)
setFst a
a (a
_,b
b) = (a
a,b
b)
    setSnd :: b -> (a, b) -> (a, b)
setSnd b
b (a
a,b
_) = (a
a,b
b)

configureExOptions :: ShowOrParseArgs
                   -> ConstraintSource
                   -> [OptionField ConfigExFlags]
configureExOptions :: ShowOrParseArgs -> ConstraintSource -> [OptionField ConfigExFlags]
configureExOptions ShowOrParseArgs
_showOrParseArgs ConstraintSource
src =
  [ forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"cabal-lib-version"]
      (String
"Select which version of the Cabal lib to use to build packages "
      forall a. [a] -> [a] -> [a]
++ String
"(useful for testing).")
      ConfigExFlags -> Flag Version
configCabalVersion (\Flag Version
v ConfigExFlags
flags -> ConfigExFlags
flags { configCabalVersion :: Flag Version
configCabalVersion = Flag Version
v })
      (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"VERSION" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (String
"Cannot parse cabal lib version: "forall a. [a] -> [a] -> [a]
++)
                                    (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Flag a
toFlag forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                        (forall a b. (a -> b) -> [a] -> [b]
map forall a. Pretty a => a -> String
prettyShowforall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Flag a -> [a]
flagToList))
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"" [String
"append"]
      String
"appending the new config to the old config file"
      ConfigExFlags -> Flag Bool
configAppend (\Flag Bool
v ConfigExFlags
flags -> ConfigExFlags
flags { configAppend :: Flag Bool
configAppend = Flag Bool
v })
      (forall a.
String
-> String -> MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
boolOpt [] [])
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"" [String
"backup"]
      String
"the backup of the config file before any alterations"
      ConfigExFlags -> Flag Bool
configBackup (\Flag Bool
v ConfigExFlags
flags -> ConfigExFlags
flags { configBackup :: Flag Bool
configBackup = Flag Bool
v })
      (forall a.
String
-> String -> MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
boolOpt [] [])
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"c" [String
"constraint"]
      String
"Specify constraints on a package (version, installed/source, flags)"
      ConfigExFlags -> [(UserConstraint, ConstraintSource)]
configExConstraints (\[(UserConstraint, ConstraintSource)]
v ConfigExFlags
flags -> ConfigExFlags
flags { configExConstraints :: [(UserConstraint, ConstraintSource)]
configExConstraints = [(UserConstraint, ConstraintSource)]
v })
      (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"CONSTRAINT"
              ((\UserConstraint
x -> [(UserConstraint
x, ConstraintSource
src)]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a. (String -> Either String a) -> ReadE a
ReadE String -> Either String UserConstraint
readUserConstraint)
              (forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a -> b) -> a -> b
$ forall a. Pretty a => a -> String
prettyShow forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"preference"]
      String
"Specify preferences (soft constraints) on the version of a package"
      ConfigExFlags -> [PackageVersionConstraint]
configPreferences (\[PackageVersionConstraint]
v ConfigExFlags
flags -> ConfigExFlags
flags { configPreferences :: [PackageVersionConstraint]
configPreferences = [PackageVersionConstraint]
v })
      (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"CONSTRAINT"
              (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (forall a b. a -> b -> a
const String
"dependency expected")
                          (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\PackageVersionConstraint
x -> [PackageVersionConstraint
x]) forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
              (forall a b. (a -> b) -> [a] -> [b]
map forall a. Pretty a => a -> String
prettyShow))

  , forall flags.
(flags -> Flag PreSolver)
-> (Flag PreSolver -> flags -> flags) -> OptionField flags
optionSolver ConfigExFlags -> Flag PreSolver
configSolver (\Flag PreSolver
v ConfigExFlags
flags -> ConfigExFlags
flags { configSolver :: Flag PreSolver
configSolver = Flag PreSolver
v })

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"allow-older"]
    (String
"Ignore lower bounds in all dependencies or DEPS")
    (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap AllowOlder -> RelaxDeps
unAllowOlder forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConfigExFlags -> Maybe AllowOlder
configAllowOlder)
    (\Maybe RelaxDeps
v ConfigExFlags
flags -> ConfigExFlags
flags { configAllowOlder :: Maybe AllowOlder
configAllowOlder = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RelaxDeps -> AllowOlder
AllowOlder Maybe RelaxDeps
v})
    (forall b a.
Monoid b =>
String
-> ReadE b
-> b
-> (b -> [Maybe String])
-> MkOptDescr (a -> b) (b -> a -> a) a
optArg String
"DEPS"
     (forall a. (ParseError -> String) -> ParsecParser a -> ReadE a
parsecToReadEErr ParseError -> String
unexpectMsgString  forall (m :: * -> *). CabalParsing m => m (Maybe RelaxDeps)
relaxDepsParser)
     (forall a. a -> Maybe a
Just RelaxDeps
RelaxDepsAll) Maybe RelaxDeps -> [Maybe String]
relaxDepsPrinter)

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"allow-newer"]
    (String
"Ignore upper bounds in all dependencies or DEPS")
    (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap AllowNewer -> RelaxDeps
unAllowNewer forall b c a. (b -> c) -> (a -> b) -> a -> c
. ConfigExFlags -> Maybe AllowNewer
configAllowNewer)
    (\Maybe RelaxDeps
v ConfigExFlags
flags -> ConfigExFlags
flags { configAllowNewer :: Maybe AllowNewer
configAllowNewer = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap RelaxDeps -> AllowNewer
AllowNewer Maybe RelaxDeps
v})
    (forall b a.
Monoid b =>
String
-> ReadE b
-> b
-> (b -> [Maybe String])
-> MkOptDescr (a -> b) (b -> a -> a) a
optArg String
"DEPS"
     (forall a. (ParseError -> String) -> ParsecParser a -> ReadE a
parsecToReadEErr ParseError -> String
unexpectMsgString  forall (m :: * -> *). CabalParsing m => m (Maybe RelaxDeps)
relaxDepsParser)
     (forall a. a -> Maybe a
Just RelaxDeps
RelaxDepsAll) Maybe RelaxDeps -> [Maybe String]
relaxDepsPrinter)

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"write-ghc-environment-files"]
    (String
"Whether to create a .ghc.environment file after a successful build"
      forall a. [a] -> [a] -> [a]
++ String
" (v2-build only)")
    ConfigExFlags -> Flag WriteGhcEnvironmentFilesPolicy
configWriteGhcEnvironmentFilesPolicy
    (\Flag WriteGhcEnvironmentFilesPolicy
v ConfigExFlags
flags -> ConfigExFlags
flags { configWriteGhcEnvironmentFilesPolicy :: Flag WriteGhcEnvironmentFilesPolicy
configWriteGhcEnvironmentFilesPolicy = Flag WriteGhcEnvironmentFilesPolicy
v})
    (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"always|never|ghc8.4.4+"
     ReadE (Flag WriteGhcEnvironmentFilesPolicy)
writeGhcEnvironmentFilesPolicyParser
     Flag WriteGhcEnvironmentFilesPolicy -> [String]
writeGhcEnvironmentFilesPolicyPrinter)
  ]


writeGhcEnvironmentFilesPolicyParser :: ReadE (Flag WriteGhcEnvironmentFilesPolicy)
writeGhcEnvironmentFilesPolicyParser :: ReadE (Flag WriteGhcEnvironmentFilesPolicy)
writeGhcEnvironmentFilesPolicyParser = forall a. (String -> Either String a) -> ReadE a
ReadE forall a b. (a -> b) -> a -> b
$ \case
  String
"always"    -> forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall a. a -> Flag a
Flag WriteGhcEnvironmentFilesPolicy
AlwaysWriteGhcEnvironmentFiles
  String
"never"     -> forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall a. a -> Flag a
Flag WriteGhcEnvironmentFilesPolicy
NeverWriteGhcEnvironmentFiles
  String
"ghc8.4.4+" -> forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ forall a. a -> Flag a
Flag WriteGhcEnvironmentFilesPolicy
WriteGhcEnvironmentFilesOnlyForGhc844AndNewer
  String
policy      -> forall a b. a -> Either a b
Left  forall a b. (a -> b) -> a -> b
$ String
"Cannot parse the GHC environment file write policy '"
                 forall a. Semigroup a => a -> a -> a
<> String
policy forall a. Semigroup a => a -> a -> a
<> String
"'"

writeGhcEnvironmentFilesPolicyPrinter
  :: Flag WriteGhcEnvironmentFilesPolicy -> [String]
writeGhcEnvironmentFilesPolicyPrinter :: Flag WriteGhcEnvironmentFilesPolicy -> [String]
writeGhcEnvironmentFilesPolicyPrinter = \case
  (Flag WriteGhcEnvironmentFilesPolicy
AlwaysWriteGhcEnvironmentFiles)                -> [String
"always"]
  (Flag WriteGhcEnvironmentFilesPolicy
NeverWriteGhcEnvironmentFiles)                 -> [String
"never"]
  (Flag WriteGhcEnvironmentFilesPolicy
WriteGhcEnvironmentFilesOnlyForGhc844AndNewer) -> [String
"ghc8.4.4+"]
  Flag WriteGhcEnvironmentFilesPolicy
NoFlag                                               -> []


relaxDepsParser :: CabalParsing m => m (Maybe RelaxDeps)
relaxDepsParser :: forall (m :: * -> *). CabalParsing m => m (Maybe RelaxDeps)
relaxDepsParser = do
  [RelaxedDep]
rs <- forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
P.sepBy forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec (forall (m :: * -> *). CharParsing m => Char -> m Char
P.char Char
',')
  if forall (t :: * -> *) a. Foldable t => t a -> Bool
null [RelaxedDep]
rs
    then forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"empty argument list is not allowed. "
             forall a. [a] -> [a] -> [a]
++ String
"Note: use --allow-newer without the equals sign to permit all "
             forall a. [a] -> [a] -> [a]
++ String
"packages to use newer versions."
    else forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. [RelaxedDep] -> RelaxDeps
RelaxDepsSome forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList forall a b. (a -> b) -> a -> b
$ [RelaxedDep]
rs

relaxDepsPrinter :: (Maybe RelaxDeps) -> [Maybe String]
relaxDepsPrinter :: Maybe RelaxDeps -> [Maybe String]
relaxDepsPrinter Maybe RelaxDeps
Nothing                     = []
relaxDepsPrinter (Just RelaxDeps
RelaxDepsAll)         = [forall a. Maybe a
Nothing]
relaxDepsPrinter (Just (RelaxDepsSome [RelaxedDep]
pkgs)) = forall a b. (a -> b) -> [a] -> [b]
map (forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Pretty a => a -> String
prettyShow) forall a b. (a -> b) -> a -> b
$ [RelaxedDep]
pkgs


instance Monoid ConfigExFlags where
  mempty :: ConfigExFlags
mempty = forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: ConfigExFlags -> ConfigExFlags -> ConfigExFlags
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup ConfigExFlags where
  <> :: ConfigExFlags -> ConfigExFlags -> ConfigExFlags
(<>) = forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend

reconfigureCommand :: CommandUI (ConfigFlags, ConfigExFlags)
reconfigureCommand :: CommandUI (ConfigFlags, ConfigExFlags)
reconfigureCommand
  = CommandUI (ConfigFlags, ConfigExFlags)
configureExCommand
    { commandName :: String
commandName         = String
"reconfigure"
    , commandSynopsis :: String
commandSynopsis     = String
"Reconfigure the package if necessary."
    , commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
         String
"Run `configure` with the most recently used flags, or append FLAGS "
         forall a. [a] -> [a] -> [a]
++ String
"to the most recently used configuration. "
         forall a. [a] -> [a] -> [a]
++ String
"Accepts the same flags as `" forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-configure'. "
         forall a. [a] -> [a] -> [a]
++ String
"If the package has never been configured, the default flags are "
         forall a. [a] -> [a] -> [a]
++ String
"used."
    , commandNotes :: Maybe (String -> String)
commandNotes        = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname ->
        String
"Examples:\n"
        forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-reconfigure\n"
        forall a. [a] -> [a] -> [a]
++ String
"    Configure with the most recently used flags.\n"
        forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-reconfigure -w PATH\n"
        forall a. [a] -> [a] -> [a]
++ String
"    Reconfigure with the most recently used flags,\n"
        forall a. [a] -> [a] -> [a]
++ String
"    but use the compiler at PATH.\n\n"
    , commandUsage :: String -> String
commandUsage        = String -> [String] -> String -> String
usageAlternatives String
"v1-reconfigure" [ String
"[FLAGS]" ]
    , commandDefaultFlags :: (ConfigFlags, ConfigExFlags)
commandDefaultFlags = forall a. Monoid a => a
mempty
    }

-- ------------------------------------------------------------
-- * Build flags
-- ------------------------------------------------------------

buildCommand :: CommandUI BuildFlags
buildCommand :: CommandUI BuildFlags
buildCommand = CommandUI BuildFlags
parent {
    commandName :: String
commandName = String
"build",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
      String
"Components encompass executables, tests, and benchmarks.\n"
        forall a. [a] -> [a] -> [a]
++ String
"\n"
        forall a. [a] -> [a] -> [a]
++ String
"Affected by configuration options, see `v1-configure`.\n",
    commandDefaultFlags :: BuildFlags
commandDefaultFlags = forall flags. CommandUI flags -> flags
commandDefaultFlags CommandUI BuildFlags
parent,
    commandUsage :: String -> String
commandUsage        = String -> [String] -> String -> String
usageAlternatives String
"v1-build" forall a b. (a -> b) -> a -> b
$
      [ String
"[FLAGS]", String
"COMPONENTS [FLAGS]" ],
    commandOptions :: ShowOrParseArgs -> [OptionField BuildFlags]
commandOptions      = forall flags.
CommandUI flags -> ShowOrParseArgs -> [OptionField flags]
commandOptions CommandUI BuildFlags
parent
    , commandNotes :: Maybe (String -> String)
commandNotes      = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname ->
      String
"Examples:\n"
        forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-build           "
        forall a. [a] -> [a] -> [a]
++ String
"    All the components in the package\n"
        forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-build foo       "
        forall a. [a] -> [a] -> [a]
++ String
"    A component (i.e. lib, exe, test suite)\n\n"
        forall a. [a] -> [a] -> [a]
++ ProgramDb -> String
Cabal.programFlagsDescription ProgramDb
defaultProgramDb
  }
  where
    parent :: CommandUI BuildFlags
parent = ProgramDb -> CommandUI BuildFlags
Cabal.buildCommand ProgramDb
defaultProgramDb

-- ------------------------------------------------------------
-- * Test flags
-- ------------------------------------------------------------

-- | Given some 'TestFlags' for the version of Cabal that
-- cabal-install was built with, and a target older 'Version' of
-- Cabal that we want to pass these flags to, convert the
-- flags into a form that will be accepted by the older
-- Setup script.  Generally speaking, this just means filtering
-- out flags that the old Cabal library doesn't understand, but
-- in some cases it may also mean "emulating" a feature using
-- some more legacy flags.
filterTestFlags :: TestFlags -> Version -> TestFlags
filterTestFlags :: TestFlags -> Version -> TestFlags
filterTestFlags TestFlags
flags Version
cabalLibVersion
  -- NB: we expect the latest version to be the most common case,
  -- so test it first.
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
3,Int
0,Int
0] = TestFlags
flags_latest
  -- The naming convention is that flags_version gives flags with
  -- all flags *introduced* in version eliminated.
  -- It is NOT the latest version of Cabal library that
  -- these flags work for; version of introduction is a more
  -- natural metric.
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
<  [Int] -> Version
mkVersion [Int
3,Int
0,Int
0] = TestFlags
flags_3_0_0
  | Bool
otherwise = forall a. HasCallStack => String -> a
error String
"the impossible just happened" -- see first guard
  where
    flags_latest :: TestFlags
flags_latest = TestFlags
flags
    flags_3_0_0 :: TestFlags
flags_3_0_0  = TestFlags
flags_latest {
      -- Cabal < 3.0 doesn't know about --test-wrapper
      testWrapper :: Flag String
Cabal.testWrapper = forall a. Flag a
NoFlag
      }

-- ------------------------------------------------------------
-- * Repl command
-- ------------------------------------------------------------

replCommand :: CommandUI ReplFlags
replCommand :: CommandUI ReplFlags
replCommand = CommandUI ReplFlags
parent {
    commandName :: String
commandName = String
"repl",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
         String
"If the current directory contains no package, ignores COMPONENT "
      forall a. [a] -> [a] -> [a]
++ String
"parameters and opens an interactive interpreter session;\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"Otherwise, (re)configures with the given or default flags, and "
      forall a. [a] -> [a] -> [a]
++ String
"loads the interpreter with the relevant modules. For executables, "
      forall a. [a] -> [a] -> [a]
++ String
"tests and benchmarks, loads the main module (and its "
      forall a. [a] -> [a] -> [a]
++ String
"dependencies); for libraries all exposed/other modules.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"The default component is the library itself, or the executable "
      forall a. [a] -> [a] -> [a]
++ String
"if that is the only component.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"Support for loading specific modules is planned but not "
      forall a. [a] -> [a] -> [a]
++ String
"implemented yet. For certain scenarios, `" forall a. [a] -> [a] -> [a]
++ String
pname
      forall a. [a] -> [a] -> [a]
++ String
" v1-exec -- ghci :l Foo` may be used instead. Note that `v1-exec` will "
      forall a. [a] -> [a] -> [a]
++ String
"not (re)configure and you will have to specify the location of "
      forall a. [a] -> [a] -> [a]
++ String
"other modules, if required.\n",
    commandUsage :: String -> String
commandUsage =  \String
pname -> String
"Usage: " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-repl [COMPONENT] [FLAGS]\n",
    commandDefaultFlags :: ReplFlags
commandDefaultFlags = forall flags. CommandUI flags -> flags
commandDefaultFlags CommandUI ReplFlags
parent,
    commandOptions :: ShowOrParseArgs -> [OptionField ReplFlags]
commandOptions      = forall flags.
CommandUI flags -> ShowOrParseArgs -> [OptionField flags]
commandOptions CommandUI ReplFlags
parent,
    commandNotes :: Maybe (String -> String)
commandNotes        = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname ->
      String
"Examples:\n"
    forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-repl           "
    forall a. [a] -> [a] -> [a]
++ String
"    The first component in the package\n"
    forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-repl foo       "
    forall a. [a] -> [a] -> [a]
++ String
"    A named component (i.e. lib, exe, test suite)\n"
    forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-repl --ghc-options=\"-lstdc++\""
    forall a. [a] -> [a] -> [a]
++ String
"  Specifying flags for interpreter\n"
  }
  where
    parent :: CommandUI ReplFlags
parent = ProgramDb -> CommandUI ReplFlags
Cabal.replCommand ProgramDb
defaultProgramDb

-- ------------------------------------------------------------
-- * Test command
-- ------------------------------------------------------------

testCommand :: CommandUI (BuildFlags, TestFlags)
testCommand :: CommandUI (BuildFlags, TestFlags)
testCommand = CommandUI TestFlags
parent {
  commandName :: String
commandName = String
"test",
  commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
         String
"If necessary (re)configures with `--enable-tests` flag and builds"
      forall a. [a] -> [a] -> [a]
++ String
" the test suite.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"Remember that the tests' dependencies must be installed if there"
      forall a. [a] -> [a] -> [a]
++ String
" are additional ones; e.g. with `" forall a. [a] -> [a] -> [a]
++ String
pname
      forall a. [a] -> [a] -> [a]
++ String
" v1-install --only-dependencies --enable-tests`.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"By defining UserHooks in a custom Setup.hs, the package can"
      forall a. [a] -> [a] -> [a]
++ String
" define actions to be executed before and after running tests.\n",
  commandUsage :: String -> String
commandUsage = String -> [String] -> String -> String
usageAlternatives String
"v1-test"
      [ String
"[FLAGS]", String
"TESTCOMPONENTS [FLAGS]" ],
  commandDefaultFlags :: (BuildFlags, TestFlags)
commandDefaultFlags = (BuildFlags
Cabal.defaultBuildFlags, forall flags. CommandUI flags -> flags
commandDefaultFlags CommandUI TestFlags
parent),
  commandOptions :: ShowOrParseArgs -> [OptionField (BuildFlags, TestFlags)]
commandOptions      =
    \ShowOrParseArgs
showOrParseArgs -> forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions forall a b. (a, b) -> a
get1 forall {a} {a} {b}. a -> (a, b) -> (a, b)
set1
                        (ProgramDb -> ShowOrParseArgs -> [OptionField BuildFlags]
Cabal.buildOptions ProgramDb
progDb ShowOrParseArgs
showOrParseArgs)
                        forall a. [a] -> [a] -> [a]
++
                        forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions forall a b. (a, b) -> b
get2 forall {b} {a} {b}. b -> (a, b) -> (a, b)
set2
                        (forall flags.
CommandUI flags -> ShowOrParseArgs -> [OptionField flags]
commandOptions CommandUI TestFlags
parent ShowOrParseArgs
showOrParseArgs)
  }
  where
    get1 :: (a, b) -> a
get1 (a
a,b
_) = a
a; set1 :: a -> (a, b) -> (a, b)
set1 a
a (a
_,b
b) = (a
a,b
b)
    get2 :: (a, b) -> b
get2 (a
_,b
b) = b
b; set2 :: b -> (a, b) -> (a, b)
set2 b
b (a
a,b
_) = (a
a,b
b)

    parent :: CommandUI TestFlags
parent = CommandUI TestFlags
Cabal.testCommand
    progDb :: ProgramDb
progDb = ProgramDb
defaultProgramDb

-- ------------------------------------------------------------
-- * Bench command
-- ------------------------------------------------------------

benchmarkCommand :: CommandUI (BuildFlags, BenchmarkFlags)
benchmarkCommand :: CommandUI (BuildFlags, BenchmarkFlags)
benchmarkCommand = CommandUI BenchmarkFlags
parent {
  commandName :: String
commandName = String
"bench",
  commandUsage :: String -> String
commandUsage = String -> [String] -> String -> String
usageAlternatives String
"v1-bench"
      [ String
"[FLAGS]", String
"BENCHCOMPONENTS [FLAGS]" ],
  commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
         String
"If necessary (re)configures with `--enable-benchmarks` flag and"
      forall a. [a] -> [a] -> [a]
++ String
" builds the benchmarks.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"Remember that the benchmarks' dependencies must be installed if"
      forall a. [a] -> [a] -> [a]
++ String
" there are additional ones; e.g. with `" forall a. [a] -> [a] -> [a]
++ String
pname
      forall a. [a] -> [a] -> [a]
++ String
" v1-install --only-dependencies --enable-benchmarks`.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"By defining UserHooks in a custom Setup.hs, the package can"
      forall a. [a] -> [a] -> [a]
++ String
" define actions to be executed before and after running"
      forall a. [a] -> [a] -> [a]
++ String
" benchmarks.\n",
  commandDefaultFlags :: (BuildFlags, BenchmarkFlags)
commandDefaultFlags = (BuildFlags
Cabal.defaultBuildFlags, forall flags. CommandUI flags -> flags
commandDefaultFlags CommandUI BenchmarkFlags
parent),
  commandOptions :: ShowOrParseArgs -> [OptionField (BuildFlags, BenchmarkFlags)]
commandOptions      =
    \ShowOrParseArgs
showOrParseArgs -> forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions forall a b. (a, b) -> a
get1 forall {a} {a} {b}. a -> (a, b) -> (a, b)
set1
                        (ProgramDb -> ShowOrParseArgs -> [OptionField BuildFlags]
Cabal.buildOptions ProgramDb
progDb ShowOrParseArgs
showOrParseArgs)
                        forall a. [a] -> [a] -> [a]
++
                        forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions forall a b. (a, b) -> b
get2 forall {b} {a} {b}. b -> (a, b) -> (a, b)
set2
                        (forall flags.
CommandUI flags -> ShowOrParseArgs -> [OptionField flags]
commandOptions CommandUI BenchmarkFlags
parent ShowOrParseArgs
showOrParseArgs)
  }
  where
    get1 :: (a, b) -> a
get1 (a
a,b
_) = a
a; set1 :: a -> (a, b) -> (a, b)
set1 a
a (a
_,b
b) = (a
a,b
b)
    get2 :: (a, b) -> b
get2 (a
_,b
b) = b
b; set2 :: b -> (a, b) -> (a, b)
set2 b
b (a
a,b
_) = (a
a,b
b)

    parent :: CommandUI BenchmarkFlags
parent = CommandUI BenchmarkFlags
Cabal.benchmarkCommand
    progDb :: ProgramDb
progDb = ProgramDb
defaultProgramDb

-- ------------------------------------------------------------
-- * Fetch command
-- ------------------------------------------------------------

data FetchFlags = FetchFlags {
--    fetchOutput    :: Flag FilePath,
      FetchFlags -> Flag Bool
fetchDeps      :: Flag Bool,
      FetchFlags -> Flag Bool
fetchDryRun    :: Flag Bool,
      FetchFlags -> Flag PreSolver
fetchSolver           :: Flag PreSolver,
      FetchFlags -> Flag Int
fetchMaxBackjumps     :: Flag Int,
      FetchFlags -> Flag ReorderGoals
fetchReorderGoals     :: Flag ReorderGoals,
      FetchFlags -> Flag CountConflicts
fetchCountConflicts   :: Flag CountConflicts,
      FetchFlags -> Flag FineGrainedConflicts
fetchFineGrainedConflicts :: Flag FineGrainedConflicts,
      FetchFlags -> Flag MinimizeConflictSet
fetchMinimizeConflictSet :: Flag MinimizeConflictSet,
      FetchFlags -> Flag IndependentGoals
fetchIndependentGoals :: Flag IndependentGoals,
      FetchFlags -> Flag PreferOldest
fetchPreferOldest     :: Flag PreferOldest,
      FetchFlags -> Flag ShadowPkgs
fetchShadowPkgs       :: Flag ShadowPkgs,
      FetchFlags -> Flag StrongFlags
fetchStrongFlags      :: Flag StrongFlags,
      FetchFlags -> Flag AllowBootLibInstalls
fetchAllowBootLibInstalls :: Flag AllowBootLibInstalls,
      FetchFlags -> Flag OnlyConstrained
fetchOnlyConstrained  :: Flag OnlyConstrained,
      FetchFlags -> Flag Bool
fetchTests            :: Flag Bool,
      FetchFlags -> Flag Bool
fetchBenchmarks       :: Flag Bool,
      FetchFlags -> Flag Verbosity
fetchVerbosity :: Flag Verbosity
    }

defaultFetchFlags :: FetchFlags
defaultFetchFlags :: FetchFlags
defaultFetchFlags = FetchFlags {
--  fetchOutput    = mempty,
    fetchDeps :: Flag Bool
fetchDeps      = forall a. a -> Flag a
toFlag Bool
True,
    fetchDryRun :: Flag Bool
fetchDryRun    = forall a. a -> Flag a
toFlag Bool
False,
    fetchSolver :: Flag PreSolver
fetchSolver           = forall a. a -> Flag a
Flag PreSolver
defaultSolver,
    fetchMaxBackjumps :: Flag Int
fetchMaxBackjumps     = forall a. a -> Flag a
Flag Int
defaultMaxBackjumps,
    fetchReorderGoals :: Flag ReorderGoals
fetchReorderGoals     = forall a. a -> Flag a
Flag (Bool -> ReorderGoals
ReorderGoals Bool
False),
    fetchCountConflicts :: Flag CountConflicts
fetchCountConflicts   = forall a. a -> Flag a
Flag (Bool -> CountConflicts
CountConflicts Bool
True),
    fetchFineGrainedConflicts :: Flag FineGrainedConflicts
fetchFineGrainedConflicts = forall a. a -> Flag a
Flag (Bool -> FineGrainedConflicts
FineGrainedConflicts Bool
True),
    fetchMinimizeConflictSet :: Flag MinimizeConflictSet
fetchMinimizeConflictSet = forall a. a -> Flag a
Flag (Bool -> MinimizeConflictSet
MinimizeConflictSet Bool
False),
    fetchIndependentGoals :: Flag IndependentGoals
fetchIndependentGoals = forall a. a -> Flag a
Flag (Bool -> IndependentGoals
IndependentGoals Bool
False),
    fetchPreferOldest :: Flag PreferOldest
fetchPreferOldest     = forall a. a -> Flag a
Flag (Bool -> PreferOldest
PreferOldest Bool
False),
    fetchShadowPkgs :: Flag ShadowPkgs
fetchShadowPkgs       = forall a. a -> Flag a
Flag (Bool -> ShadowPkgs
ShadowPkgs Bool
False),
    fetchStrongFlags :: Flag StrongFlags
fetchStrongFlags      = forall a. a -> Flag a
Flag (Bool -> StrongFlags
StrongFlags Bool
False),
    fetchAllowBootLibInstalls :: Flag AllowBootLibInstalls
fetchAllowBootLibInstalls = forall a. a -> Flag a
Flag (Bool -> AllowBootLibInstalls
AllowBootLibInstalls Bool
False),
    fetchOnlyConstrained :: Flag OnlyConstrained
fetchOnlyConstrained  = forall a. a -> Flag a
Flag OnlyConstrained
OnlyConstrainedNone,
    fetchTests :: Flag Bool
fetchTests            = forall a. a -> Flag a
toFlag Bool
False,
    fetchBenchmarks :: Flag Bool
fetchBenchmarks       = forall a. a -> Flag a
toFlag Bool
False,
    fetchVerbosity :: Flag Verbosity
fetchVerbosity = forall a. a -> Flag a
toFlag Verbosity
normal
   }

fetchCommand :: CommandUI FetchFlags
fetchCommand :: CommandUI FetchFlags
fetchCommand = CommandUI {
    commandName :: String
commandName         = String
"fetch",
    commandSynopsis :: String
commandSynopsis     = String
"Downloads packages for later installation.",
    commandUsage :: String -> String
commandUsage        = String -> [String] -> String -> String
usageAlternatives String
"fetch" [ String
"[FLAGS] PACKAGES"
                                                    ],
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ ->
          String
"Note that it currently is not possible to fetch the dependencies for a\n"
       forall a. [a] -> [a] -> [a]
++ String
"package in the current directory.\n",
    commandNotes :: Maybe (String -> String)
commandNotes        = forall a. Maybe a
Nothing,
    commandDefaultFlags :: FetchFlags
commandDefaultFlags = FetchFlags
defaultFetchFlags,
    commandOptions :: ShowOrParseArgs -> [OptionField FetchFlags]
commandOptions      = \ ShowOrParseArgs
showOrParseArgs -> [
         forall flags.
(flags -> Flag Verbosity)
-> (Flag Verbosity -> flags -> flags) -> OptionField flags
optionVerbosity FetchFlags -> Flag Verbosity
fetchVerbosity (\Flag Verbosity
v FetchFlags
flags -> FetchFlags
flags { fetchVerbosity :: Flag Verbosity
fetchVerbosity = Flag Verbosity
v })

--     , option "o" ["output"]
--         "Put the package(s) somewhere specific rather than the usual cache."
--         fetchOutput (\v flags -> flags { fetchOutput = v })
--         (reqArgFlag "PATH")

       , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"dependencies", String
"deps"]
           String
"Resolve and fetch dependencies (default)"
           FetchFlags -> Flag Bool
fetchDeps (\Flag Bool
v FetchFlags
flags -> FetchFlags
flags { fetchDeps :: Flag Bool
fetchDeps = Flag Bool
v })
           forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

       , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"no-dependencies", String
"no-deps"]
           String
"Ignore dependencies"
           FetchFlags -> Flag Bool
fetchDeps (\Flag Bool
v FetchFlags
flags -> FetchFlags
flags { fetchDeps :: Flag Bool
fetchDeps = Flag Bool
v })
           forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
falseArg

       , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"dry-run"]
           String
"Do not install anything, only print what would be installed."
           FetchFlags -> Flag Bool
fetchDryRun (\Flag Bool
v FetchFlags
flags -> FetchFlags
flags { fetchDryRun :: Flag Bool
fetchDryRun = Flag Bool
v })
           forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"" [String
"tests"]
         String
"dependency checking and compilation for test suites listed in the package description file."
         FetchFlags -> Flag Bool
fetchTests (\Flag Bool
v FetchFlags
flags -> FetchFlags
flags { fetchTests :: Flag Bool
fetchTests = Flag Bool
v })
         (forall a.
String
-> String -> MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
boolOpt [] [])

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"" [String
"benchmarks"]
         String
"dependency checking and compilation for benchmarks listed in the package description file."
         FetchFlags -> Flag Bool
fetchBenchmarks (\Flag Bool
v FetchFlags
flags -> FetchFlags
flags { fetchBenchmarks :: Flag Bool
fetchBenchmarks = Flag Bool
v })
         (forall a.
String
-> String -> MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
boolOpt [] [])

       ] forall a. [a] -> [a] -> [a]
++

       forall flags.
(flags -> Flag PreSolver)
-> (Flag PreSolver -> flags -> flags) -> OptionField flags
optionSolver      FetchFlags -> Flag PreSolver
fetchSolver           (\Flag PreSolver
v FetchFlags
flags -> FetchFlags
flags { fetchSolver :: Flag PreSolver
fetchSolver           = Flag PreSolver
v }) forall a. a -> [a] -> [a]
:
       forall flags.
ShowOrParseArgs
-> (flags -> Flag Int)
-> (Flag Int -> flags -> flags)
-> (flags -> Flag ReorderGoals)
-> (Flag ReorderGoals -> flags -> flags)
-> (flags -> Flag CountConflicts)
-> (Flag CountConflicts -> flags -> flags)
-> (flags -> Flag FineGrainedConflicts)
-> (Flag FineGrainedConflicts -> flags -> flags)
-> (flags -> Flag MinimizeConflictSet)
-> (Flag MinimizeConflictSet -> flags -> flags)
-> (flags -> Flag IndependentGoals)
-> (Flag IndependentGoals -> flags -> flags)
-> (flags -> Flag PreferOldest)
-> (Flag PreferOldest -> flags -> flags)
-> (flags -> Flag ShadowPkgs)
-> (Flag ShadowPkgs -> flags -> flags)
-> (flags -> Flag StrongFlags)
-> (Flag StrongFlags -> flags -> flags)
-> (flags -> Flag AllowBootLibInstalls)
-> (Flag AllowBootLibInstalls -> flags -> flags)
-> (flags -> Flag OnlyConstrained)
-> (Flag OnlyConstrained -> flags -> flags)
-> [OptionField flags]
optionSolverFlags ShowOrParseArgs
showOrParseArgs
                         FetchFlags -> Flag Int
fetchMaxBackjumps     (\Flag Int
v FetchFlags
flags -> FetchFlags
flags { fetchMaxBackjumps :: Flag Int
fetchMaxBackjumps     = Flag Int
v })
                         FetchFlags -> Flag ReorderGoals
fetchReorderGoals     (\Flag ReorderGoals
v FetchFlags
flags -> FetchFlags
flags { fetchReorderGoals :: Flag ReorderGoals
fetchReorderGoals     = Flag ReorderGoals
v })
                         FetchFlags -> Flag CountConflicts
fetchCountConflicts   (\Flag CountConflicts
v FetchFlags
flags -> FetchFlags
flags { fetchCountConflicts :: Flag CountConflicts
fetchCountConflicts   = Flag CountConflicts
v })
                         FetchFlags -> Flag FineGrainedConflicts
fetchFineGrainedConflicts (\Flag FineGrainedConflicts
v FetchFlags
flags -> FetchFlags
flags { fetchFineGrainedConflicts :: Flag FineGrainedConflicts
fetchFineGrainedConflicts = Flag FineGrainedConflicts
v })
                         FetchFlags -> Flag MinimizeConflictSet
fetchMinimizeConflictSet (\Flag MinimizeConflictSet
v FetchFlags
flags -> FetchFlags
flags { fetchMinimizeConflictSet :: Flag MinimizeConflictSet
fetchMinimizeConflictSet = Flag MinimizeConflictSet
v })
                         FetchFlags -> Flag IndependentGoals
fetchIndependentGoals (\Flag IndependentGoals
v FetchFlags
flags -> FetchFlags
flags { fetchIndependentGoals :: Flag IndependentGoals
fetchIndependentGoals = Flag IndependentGoals
v })
                         FetchFlags -> Flag PreferOldest
fetchPreferOldest     (\Flag PreferOldest
v FetchFlags
flags -> FetchFlags
flags { fetchPreferOldest :: Flag PreferOldest
fetchPreferOldest = Flag PreferOldest
v })
                         FetchFlags -> Flag ShadowPkgs
fetchShadowPkgs       (\Flag ShadowPkgs
v FetchFlags
flags -> FetchFlags
flags { fetchShadowPkgs :: Flag ShadowPkgs
fetchShadowPkgs       = Flag ShadowPkgs
v })
                         FetchFlags -> Flag StrongFlags
fetchStrongFlags      (\Flag StrongFlags
v FetchFlags
flags -> FetchFlags
flags { fetchStrongFlags :: Flag StrongFlags
fetchStrongFlags      = Flag StrongFlags
v })
                         FetchFlags -> Flag AllowBootLibInstalls
fetchAllowBootLibInstalls (\Flag AllowBootLibInstalls
v FetchFlags
flags -> FetchFlags
flags { fetchAllowBootLibInstalls :: Flag AllowBootLibInstalls
fetchAllowBootLibInstalls = Flag AllowBootLibInstalls
v })
                         FetchFlags -> Flag OnlyConstrained
fetchOnlyConstrained  (\Flag OnlyConstrained
v FetchFlags
flags -> FetchFlags
flags { fetchOnlyConstrained :: Flag OnlyConstrained
fetchOnlyConstrained  = Flag OnlyConstrained
v })

  }

-- ------------------------------------------------------------
-- * Freeze command
-- ------------------------------------------------------------

data FreezeFlags = FreezeFlags {
      FreezeFlags -> Flag Bool
freezeDryRun           :: Flag Bool,
      FreezeFlags -> Flag Bool
freezeTests            :: Flag Bool,
      FreezeFlags -> Flag Bool
freezeBenchmarks       :: Flag Bool,
      FreezeFlags -> Flag PreSolver
freezeSolver           :: Flag PreSolver,
      FreezeFlags -> Flag Int
freezeMaxBackjumps     :: Flag Int,
      FreezeFlags -> Flag ReorderGoals
freezeReorderGoals     :: Flag ReorderGoals,
      FreezeFlags -> Flag CountConflicts
freezeCountConflicts   :: Flag CountConflicts,
      FreezeFlags -> Flag FineGrainedConflicts
freezeFineGrainedConflicts :: Flag FineGrainedConflicts,
      FreezeFlags -> Flag MinimizeConflictSet
freezeMinimizeConflictSet :: Flag MinimizeConflictSet,
      FreezeFlags -> Flag IndependentGoals
freezeIndependentGoals :: Flag IndependentGoals,
      FreezeFlags -> Flag PreferOldest
freezePreferOldest     :: Flag PreferOldest,
      FreezeFlags -> Flag ShadowPkgs
freezeShadowPkgs       :: Flag ShadowPkgs,
      FreezeFlags -> Flag StrongFlags
freezeStrongFlags      :: Flag StrongFlags,
      FreezeFlags -> Flag AllowBootLibInstalls
freezeAllowBootLibInstalls :: Flag AllowBootLibInstalls,
      FreezeFlags -> Flag OnlyConstrained
freezeOnlyConstrained  :: Flag OnlyConstrained,
      FreezeFlags -> Flag Verbosity
freezeVerbosity        :: Flag Verbosity
    }

defaultFreezeFlags :: FreezeFlags
defaultFreezeFlags :: FreezeFlags
defaultFreezeFlags = FreezeFlags {
    freezeDryRun :: Flag Bool
freezeDryRun           = forall a. a -> Flag a
toFlag Bool
False,
    freezeTests :: Flag Bool
freezeTests            = forall a. a -> Flag a
toFlag Bool
False,
    freezeBenchmarks :: Flag Bool
freezeBenchmarks       = forall a. a -> Flag a
toFlag Bool
False,
    freezeSolver :: Flag PreSolver
freezeSolver           = forall a. a -> Flag a
Flag PreSolver
defaultSolver,
    freezeMaxBackjumps :: Flag Int
freezeMaxBackjumps     = forall a. a -> Flag a
Flag Int
defaultMaxBackjumps,
    freezeReorderGoals :: Flag ReorderGoals
freezeReorderGoals     = forall a. a -> Flag a
Flag (Bool -> ReorderGoals
ReorderGoals Bool
False),
    freezeCountConflicts :: Flag CountConflicts
freezeCountConflicts   = forall a. a -> Flag a
Flag (Bool -> CountConflicts
CountConflicts Bool
True),
    freezeFineGrainedConflicts :: Flag FineGrainedConflicts
freezeFineGrainedConflicts = forall a. a -> Flag a
Flag (Bool -> FineGrainedConflicts
FineGrainedConflicts Bool
True),
    freezeMinimizeConflictSet :: Flag MinimizeConflictSet
freezeMinimizeConflictSet = forall a. a -> Flag a
Flag (Bool -> MinimizeConflictSet
MinimizeConflictSet Bool
False),
    freezeIndependentGoals :: Flag IndependentGoals
freezeIndependentGoals = forall a. a -> Flag a
Flag (Bool -> IndependentGoals
IndependentGoals Bool
False),
    freezePreferOldest :: Flag PreferOldest
freezePreferOldest     = forall a. a -> Flag a
Flag (Bool -> PreferOldest
PreferOldest Bool
False),
    freezeShadowPkgs :: Flag ShadowPkgs
freezeShadowPkgs       = forall a. a -> Flag a
Flag (Bool -> ShadowPkgs
ShadowPkgs Bool
False),
    freezeStrongFlags :: Flag StrongFlags
freezeStrongFlags      = forall a. a -> Flag a
Flag (Bool -> StrongFlags
StrongFlags Bool
False),
    freezeAllowBootLibInstalls :: Flag AllowBootLibInstalls
freezeAllowBootLibInstalls = forall a. a -> Flag a
Flag (Bool -> AllowBootLibInstalls
AllowBootLibInstalls Bool
False),
    freezeOnlyConstrained :: Flag OnlyConstrained
freezeOnlyConstrained  = forall a. a -> Flag a
Flag OnlyConstrained
OnlyConstrainedNone,
    freezeVerbosity :: Flag Verbosity
freezeVerbosity        = forall a. a -> Flag a
toFlag Verbosity
normal
   }

freezeCommand :: CommandUI FreezeFlags
freezeCommand :: CommandUI FreezeFlags
freezeCommand = CommandUI {
    commandName :: String
commandName         = String
"freeze",
    commandSynopsis :: String
commandSynopsis     = String
"Freeze dependencies.",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
         String
"Calculates a valid set of dependencies and their exact versions. "
      forall a. [a] -> [a] -> [a]
++ String
"If successful, saves the result to the file `cabal.config`.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"The package versions specified in `cabal.config` will be used for "
      forall a. [a] -> [a] -> [a]
++ String
"any future installs.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"An existing `cabal.config` is ignored and overwritten.\n",
    commandNotes :: Maybe (String -> String)
commandNotes        = forall a. Maybe a
Nothing,
    commandUsage :: String -> String
commandUsage        = String -> String -> String
usageFlags String
"freeze",
    commandDefaultFlags :: FreezeFlags
commandDefaultFlags = FreezeFlags
defaultFreezeFlags,
    commandOptions :: ShowOrParseArgs -> [OptionField FreezeFlags]
commandOptions      = \ ShowOrParseArgs
showOrParseArgs -> [
         forall flags.
(flags -> Flag Verbosity)
-> (Flag Verbosity -> flags -> flags) -> OptionField flags
optionVerbosity FreezeFlags -> Flag Verbosity
freezeVerbosity
         (\Flag Verbosity
v FreezeFlags
flags -> FreezeFlags
flags { freezeVerbosity :: Flag Verbosity
freezeVerbosity = Flag Verbosity
v })

       , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"dry-run"]
           String
"Do not freeze anything, only print what would be frozen"
           FreezeFlags -> Flag Bool
freezeDryRun (\Flag Bool
v FreezeFlags
flags -> FreezeFlags
flags { freezeDryRun :: Flag Bool
freezeDryRun = Flag Bool
v })
           forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

       , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"tests"]
           (String
"freezing of the dependencies of any tests suites "
            forall a. [a] -> [a] -> [a]
++ String
"in the package description file.")
           FreezeFlags -> Flag Bool
freezeTests (\Flag Bool
v FreezeFlags
flags -> FreezeFlags
flags { freezeTests :: Flag Bool
freezeTests = Flag Bool
v })
           (forall a.
String
-> String -> MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
boolOpt [] [])

       , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"benchmarks"]
           (String
"freezing of the dependencies of any benchmarks suites "
            forall a. [a] -> [a] -> [a]
++ String
"in the package description file.")
           FreezeFlags -> Flag Bool
freezeBenchmarks (\Flag Bool
v FreezeFlags
flags -> FreezeFlags
flags { freezeBenchmarks :: Flag Bool
freezeBenchmarks = Flag Bool
v })
           (forall a.
String
-> String -> MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
boolOpt [] [])

       ] forall a. [a] -> [a] -> [a]
++

       forall flags.
(flags -> Flag PreSolver)
-> (Flag PreSolver -> flags -> flags) -> OptionField flags
optionSolver
         FreezeFlags -> Flag PreSolver
freezeSolver           (\Flag PreSolver
v FreezeFlags
flags -> FreezeFlags
flags { freezeSolver :: Flag PreSolver
freezeSolver           = Flag PreSolver
v })forall a. a -> [a] -> [a]
:
       forall flags.
ShowOrParseArgs
-> (flags -> Flag Int)
-> (Flag Int -> flags -> flags)
-> (flags -> Flag ReorderGoals)
-> (Flag ReorderGoals -> flags -> flags)
-> (flags -> Flag CountConflicts)
-> (Flag CountConflicts -> flags -> flags)
-> (flags -> Flag FineGrainedConflicts)
-> (Flag FineGrainedConflicts -> flags -> flags)
-> (flags -> Flag MinimizeConflictSet)
-> (Flag MinimizeConflictSet -> flags -> flags)
-> (flags -> Flag IndependentGoals)
-> (Flag IndependentGoals -> flags -> flags)
-> (flags -> Flag PreferOldest)
-> (Flag PreferOldest -> flags -> flags)
-> (flags -> Flag ShadowPkgs)
-> (Flag ShadowPkgs -> flags -> flags)
-> (flags -> Flag StrongFlags)
-> (Flag StrongFlags -> flags -> flags)
-> (flags -> Flag AllowBootLibInstalls)
-> (Flag AllowBootLibInstalls -> flags -> flags)
-> (flags -> Flag OnlyConstrained)
-> (Flag OnlyConstrained -> flags -> flags)
-> [OptionField flags]
optionSolverFlags ShowOrParseArgs
showOrParseArgs
                         FreezeFlags -> Flag Int
freezeMaxBackjumps     (\Flag Int
v FreezeFlags
flags -> FreezeFlags
flags { freezeMaxBackjumps :: Flag Int
freezeMaxBackjumps     = Flag Int
v })
                         FreezeFlags -> Flag ReorderGoals
freezeReorderGoals     (\Flag ReorderGoals
v FreezeFlags
flags -> FreezeFlags
flags { freezeReorderGoals :: Flag ReorderGoals
freezeReorderGoals     = Flag ReorderGoals
v })
                         FreezeFlags -> Flag CountConflicts
freezeCountConflicts   (\Flag CountConflicts
v FreezeFlags
flags -> FreezeFlags
flags { freezeCountConflicts :: Flag CountConflicts
freezeCountConflicts   = Flag CountConflicts
v })
                         FreezeFlags -> Flag FineGrainedConflicts
freezeFineGrainedConflicts (\Flag FineGrainedConflicts
v FreezeFlags
flags -> FreezeFlags
flags { freezeFineGrainedConflicts :: Flag FineGrainedConflicts
freezeFineGrainedConflicts = Flag FineGrainedConflicts
v })
                         FreezeFlags -> Flag MinimizeConflictSet
freezeMinimizeConflictSet (\Flag MinimizeConflictSet
v FreezeFlags
flags -> FreezeFlags
flags { freezeMinimizeConflictSet :: Flag MinimizeConflictSet
freezeMinimizeConflictSet = Flag MinimizeConflictSet
v })
                         FreezeFlags -> Flag IndependentGoals
freezeIndependentGoals (\Flag IndependentGoals
v FreezeFlags
flags -> FreezeFlags
flags { freezeIndependentGoals :: Flag IndependentGoals
freezeIndependentGoals = Flag IndependentGoals
v })
                         FreezeFlags -> Flag PreferOldest
freezePreferOldest     (\Flag PreferOldest
v FreezeFlags
flags -> FreezeFlags
flags { freezePreferOldest :: Flag PreferOldest
freezePreferOldest = Flag PreferOldest
v })
                         FreezeFlags -> Flag ShadowPkgs
freezeShadowPkgs       (\Flag ShadowPkgs
v FreezeFlags
flags -> FreezeFlags
flags { freezeShadowPkgs :: Flag ShadowPkgs
freezeShadowPkgs       = Flag ShadowPkgs
v })
                         FreezeFlags -> Flag StrongFlags
freezeStrongFlags      (\Flag StrongFlags
v FreezeFlags
flags -> FreezeFlags
flags { freezeStrongFlags :: Flag StrongFlags
freezeStrongFlags      = Flag StrongFlags
v })
                         FreezeFlags -> Flag AllowBootLibInstalls
freezeAllowBootLibInstalls (\Flag AllowBootLibInstalls
v FreezeFlags
flags -> FreezeFlags
flags { freezeAllowBootLibInstalls :: Flag AllowBootLibInstalls
freezeAllowBootLibInstalls = Flag AllowBootLibInstalls
v })
                         FreezeFlags -> Flag OnlyConstrained
freezeOnlyConstrained  (\Flag OnlyConstrained
v FreezeFlags
flags -> FreezeFlags
flags { freezeOnlyConstrained :: Flag OnlyConstrained
freezeOnlyConstrained  = Flag OnlyConstrained
v })

  }

-- ------------------------------------------------------------
-- * 'gen-bounds' command
-- ------------------------------------------------------------

genBoundsCommand :: CommandUI FreezeFlags
genBoundsCommand :: CommandUI FreezeFlags
genBoundsCommand = CommandUI {
    commandName :: String
commandName         = String
"gen-bounds",
    commandSynopsis :: String
commandSynopsis     = String
"Generate dependency bounds.",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
         String
"Generates bounds for all dependencies that do not currently have them. "
      forall a. [a] -> [a] -> [a]
++ String
"Generated bounds are printed to stdout.  "
      forall a. [a] -> [a] -> [a]
++ String
"You can then paste them into your .cabal file.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n",
    commandNotes :: Maybe (String -> String)
commandNotes        = forall a. Maybe a
Nothing,
    commandUsage :: String -> String
commandUsage        = String -> String -> String
usageFlags String
"gen-bounds",
    commandDefaultFlags :: FreezeFlags
commandDefaultFlags = FreezeFlags
defaultFreezeFlags,
    commandOptions :: ShowOrParseArgs -> [OptionField FreezeFlags]
commandOptions      = \ ShowOrParseArgs
_ -> [
     forall flags.
(flags -> Flag Verbosity)
-> (Flag Verbosity -> flags -> flags) -> OptionField flags
optionVerbosity FreezeFlags -> Flag Verbosity
freezeVerbosity (\Flag Verbosity
v FreezeFlags
flags -> FreezeFlags
flags { freezeVerbosity :: Flag Verbosity
freezeVerbosity = Flag Verbosity
v })
     ]
  }

-- ------------------------------------------------------------
-- * Update command
-- ------------------------------------------------------------

data UpdateFlags
    = UpdateFlags {
        UpdateFlags -> Flag Verbosity
updateVerbosity  :: Flag Verbosity,
        UpdateFlags -> Flag TotalIndexState
updateIndexState :: Flag TotalIndexState
    } deriving forall x. Rep UpdateFlags x -> UpdateFlags
forall x. UpdateFlags -> Rep UpdateFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateFlags x -> UpdateFlags
$cfrom :: forall x. UpdateFlags -> Rep UpdateFlags x
Generic

defaultUpdateFlags :: UpdateFlags
defaultUpdateFlags :: UpdateFlags
defaultUpdateFlags
    = UpdateFlags {
        updateVerbosity :: Flag Verbosity
updateVerbosity  = forall a. a -> Flag a
toFlag Verbosity
normal,
        updateIndexState :: Flag TotalIndexState
updateIndexState = forall a. a -> Flag a
toFlag TotalIndexState
headTotalIndexState
    }

-- ------------------------------------------------------------
-- * Other commands
-- ------------------------------------------------------------

cleanCommand :: CommandUI CleanFlags
cleanCommand :: CommandUI CleanFlags
cleanCommand = CommandUI CleanFlags
Cabal.cleanCommand
  { commandUsage :: String -> String
commandUsage = \String
pname ->
    String
"Usage: " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-clean [FLAGS]\n"
  }

checkCommand  :: CommandUI (Flag Verbosity)
checkCommand :: CommandUI (Flag Verbosity)
checkCommand = CommandUI {
    commandName :: String
commandName         = String
"check",
    commandSynopsis :: String
commandSynopsis     = String
"Check the package for common mistakes.",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
         String
"Expects a .cabal package file in the current directory.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"The checks correspond to the requirements to packages on Hackage. "
      forall a. [a] -> [a] -> [a]
++ String
"If no errors and warnings are reported, Hackage will accept this "
      forall a. [a] -> [a] -> [a]
++ String
"package.\n",
    commandNotes :: Maybe (String -> String)
commandNotes        = forall a. Maybe a
Nothing,
    commandUsage :: String -> String
commandUsage        = String -> String -> String
usageFlags String
"check",
    commandDefaultFlags :: Flag Verbosity
commandDefaultFlags = forall a. a -> Flag a
toFlag Verbosity
normal,
    commandOptions :: ShowOrParseArgs -> [OptionField (Flag Verbosity)]
commandOptions      = \ShowOrParseArgs
_ -> [forall flags.
(flags -> Flag Verbosity)
-> (Flag Verbosity -> flags -> flags) -> OptionField flags
optionVerbosity forall a. a -> a
id forall a b. a -> b -> a
const]
  }

formatCommand  :: CommandUI (Flag Verbosity)
formatCommand :: CommandUI (Flag Verbosity)
formatCommand = CommandUI {
    commandName :: String
commandName         = String
"format",
    commandSynopsis :: String
commandSynopsis     = String
"Reformat the .cabal file using the standard style.",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. Maybe a
Nothing,
    commandNotes :: Maybe (String -> String)
commandNotes        = forall a. Maybe a
Nothing,
    commandUsage :: String -> String
commandUsage        = String -> [String] -> String -> String
usageAlternatives String
"format" [String
"[FILE]"],
    commandDefaultFlags :: Flag Verbosity
commandDefaultFlags = forall a. a -> Flag a
toFlag Verbosity
normal,
    commandOptions :: ShowOrParseArgs -> [OptionField (Flag Verbosity)]
commandOptions      = \ShowOrParseArgs
_ -> []
  }

manpageCommand :: CommandUI ManpageFlags
manpageCommand :: CommandUI ManpageFlags
manpageCommand = CommandUI {
    commandName :: String
commandName         = String
"man",
    commandSynopsis :: String
commandSynopsis     = String
"Outputs manpage source.",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ ->
      String
"Output manpage source to STDOUT.\n",
    commandNotes :: Maybe (String -> String)
commandNotes        = forall a. Maybe a
Nothing,
    commandUsage :: String -> String
commandUsage        = String -> String -> String
usageFlags String
"man",
    commandDefaultFlags :: ManpageFlags
commandDefaultFlags = ManpageFlags
defaultManpageFlags,
    commandOptions :: ShowOrParseArgs -> [OptionField ManpageFlags]
commandOptions      = ShowOrParseArgs -> [OptionField ManpageFlags]
manpageOptions
  }

runCommand :: CommandUI BuildFlags
runCommand :: CommandUI BuildFlags
runCommand = CommandUI {
    commandName :: String
commandName         = String
"run",
    commandSynopsis :: String
commandSynopsis     = String
"Builds and runs an executable.",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
         String
"Builds and then runs the specified executable. If no executable is "
      forall a. [a] -> [a] -> [a]
++ String
"specified, but the package contains just one executable, that one "
      forall a. [a] -> [a] -> [a]
++ String
"is built and executed.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"Use `" forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-test --show-details=streaming` to run a "
      forall a. [a] -> [a] -> [a]
++ String
"test-suite and get its full output.\n",
    commandNotes :: Maybe (String -> String)
commandNotes        = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname ->
          String
"Examples:\n"
       forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-run\n"
       forall a. [a] -> [a] -> [a]
++ String
"    Run the only executable in the current package;\n"
       forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-run foo -- --fooflag\n"
       forall a. [a] -> [a] -> [a]
++ String
"    Works similar to `./foo --fooflag`.\n",
    commandUsage :: String -> String
commandUsage        = String -> [String] -> String -> String
usageAlternatives String
"v1-run"
        [String
"[FLAGS] [EXECUTABLE] [-- EXECUTABLE_FLAGS]"],
    commandDefaultFlags :: BuildFlags
commandDefaultFlags = forall a. Monoid a => a
mempty,
    commandOptions :: ShowOrParseArgs -> [OptionField BuildFlags]
commandOptions      = forall flags.
CommandUI flags -> ShowOrParseArgs -> [OptionField flags]
commandOptions CommandUI BuildFlags
parent
  }
  where
    parent :: CommandUI BuildFlags
parent = ProgramDb -> CommandUI BuildFlags
Cabal.buildCommand ProgramDb
defaultProgramDb

-- ------------------------------------------------------------
-- * Report flags
-- ------------------------------------------------------------

data ReportFlags = ReportFlags {
    ReportFlags -> Flag Username
reportUsername  :: Flag Username,
    ReportFlags -> Flag Password
reportPassword  :: Flag Password,
    ReportFlags -> Flag Verbosity
reportVerbosity :: Flag Verbosity
  } deriving forall x. Rep ReportFlags x -> ReportFlags
forall x. ReportFlags -> Rep ReportFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ReportFlags x -> ReportFlags
$cfrom :: forall x. ReportFlags -> Rep ReportFlags x
Generic

defaultReportFlags :: ReportFlags
defaultReportFlags :: ReportFlags
defaultReportFlags = ReportFlags {
    reportUsername :: Flag Username
reportUsername  = forall a. Monoid a => a
mempty,
    reportPassword :: Flag Password
reportPassword  = forall a. Monoid a => a
mempty,
    reportVerbosity :: Flag Verbosity
reportVerbosity = forall a. a -> Flag a
toFlag Verbosity
normal
  }

reportCommand :: CommandUI ReportFlags
reportCommand :: CommandUI ReportFlags
reportCommand = CommandUI {
    commandName :: String
commandName         = String
"report",
    commandSynopsis :: String
commandSynopsis     = String
"Upload build reports to a remote server.",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. Maybe a
Nothing,
    commandNotes :: Maybe (String -> String)
commandNotes        = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ ->
         String
"You can store your Hackage login in the ~/.config/cabal/config file\n",
    commandUsage :: String -> String
commandUsage        = String -> [String] -> String -> String
usageAlternatives String
"report" [String
"[FLAGS]"],
    commandDefaultFlags :: ReportFlags
commandDefaultFlags = ReportFlags
defaultReportFlags,
    commandOptions :: ShowOrParseArgs -> [OptionField ReportFlags]
commandOptions      = \ShowOrParseArgs
_ ->
      [forall flags.
(flags -> Flag Verbosity)
-> (Flag Verbosity -> flags -> flags) -> OptionField flags
optionVerbosity ReportFlags -> Flag Verbosity
reportVerbosity (\Flag Verbosity
v ReportFlags
flags -> ReportFlags
flags { reportVerbosity :: Flag Verbosity
reportVerbosity = Flag Verbosity
v })

      ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'u'] [String
"username"]
        String
"Hackage username."
        ReportFlags -> Flag Username
reportUsername (\Flag Username
v ReportFlags
flags -> ReportFlags
flags { reportUsername :: Flag Username
reportUsername = Flag Username
v })
        (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"USERNAME" (forall a. a -> Flag a
toFlag forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Username
Username)
                            (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Username -> String
unUsername))

      ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'p'] [String
"password"]
        String
"Hackage password."
        ReportFlags -> Flag Password
reportPassword (\Flag Password
v ReportFlags
flags -> ReportFlags
flags { reportPassword :: Flag Password
reportPassword = Flag Password
v })
        (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"PASSWORD" (forall a. a -> Flag a
toFlag forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Password
Password)
                            (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Password -> String
unPassword))
      ]
  }

instance Monoid ReportFlags where
  mempty :: ReportFlags
mempty = forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: ReportFlags -> ReportFlags -> ReportFlags
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup ReportFlags where
  <> :: ReportFlags -> ReportFlags -> ReportFlags
(<>) = forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend

-- ------------------------------------------------------------
-- * Get flags
-- ------------------------------------------------------------

data GetFlags = GetFlags {
    GetFlags -> Flag String
getDestDir          :: Flag FilePath,
    GetFlags -> Flag Bool
getOnlyPkgDescr     :: Flag Bool,
    GetFlags -> Flag Bool
getPristine         :: Flag Bool,
    GetFlags -> Flag TotalIndexState
getIndexState       :: Flag TotalIndexState,
    GetFlags -> Flag ActiveRepos
getActiveRepos      :: Flag ActiveRepos,
    GetFlags -> Flag (Maybe RepoKind)
getSourceRepository :: Flag (Maybe RepoKind),
    GetFlags -> Flag Verbosity
getVerbosity        :: Flag Verbosity
  } deriving forall x. Rep GetFlags x -> GetFlags
forall x. GetFlags -> Rep GetFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetFlags x -> GetFlags
$cfrom :: forall x. GetFlags -> Rep GetFlags x
Generic

defaultGetFlags :: GetFlags
defaultGetFlags :: GetFlags
defaultGetFlags = GetFlags {
    getDestDir :: Flag String
getDestDir          = forall a. Monoid a => a
mempty,
    getOnlyPkgDescr :: Flag Bool
getOnlyPkgDescr     = forall a. Monoid a => a
mempty,
    getPristine :: Flag Bool
getPristine         = forall a. Monoid a => a
mempty,
    getIndexState :: Flag TotalIndexState
getIndexState       = forall a. Monoid a => a
mempty,
    getActiveRepos :: Flag ActiveRepos
getActiveRepos      = forall a. Monoid a => a
mempty,
    getSourceRepository :: Flag (Maybe RepoKind)
getSourceRepository = forall a. Monoid a => a
mempty,
    getVerbosity :: Flag Verbosity
getVerbosity        = forall a. a -> Flag a
toFlag Verbosity
normal
   }

getCommand :: CommandUI GetFlags
getCommand :: CommandUI GetFlags
getCommand = CommandUI {
    commandName :: String
commandName         = String
"get",
    commandSynopsis :: String
commandSynopsis     = String
"Download/Extract a package's source code (repository).",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$ [String] -> String
unlines [String]
descriptionOfGetCommand,
    commandNotes :: Maybe (String -> String)
commandNotes        = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname -> [String] -> String
unlines forall a b. (a -> b) -> a -> b
$ String -> String -> [String]
notesOfGetCommand String
"get" String
pname,
    commandUsage :: String -> String
commandUsage        = String -> String -> String
usagePackages String
"get",
    commandDefaultFlags :: GetFlags
commandDefaultFlags = GetFlags
defaultGetFlags,
    commandOptions :: ShowOrParseArgs -> [OptionField GetFlags]
commandOptions      = \ShowOrParseArgs
_ -> [
        forall flags.
(flags -> Flag Verbosity)
-> (Flag Verbosity -> flags -> flags) -> OptionField flags
optionVerbosity GetFlags -> Flag Verbosity
getVerbosity (\Flag Verbosity
v GetFlags
flags -> GetFlags
flags { getVerbosity :: Flag Verbosity
getVerbosity = Flag Verbosity
v })

       ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"d" [String
"destdir"]
         String
"Where to place the package source, defaults to the current directory."
         GetFlags -> Flag String
getDestDir (\Flag String
v GetFlags
flags -> GetFlags
flags { getDestDir :: Flag String
getDestDir = Flag String
v })
         (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"PATH")

       ,forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"s" [String
"source-repository"]
         String
"Copy the package's source repository (ie git clone, darcs get, etc as appropriate)."
         GetFlags -> Flag (Maybe RepoKind)
getSourceRepository (\Flag (Maybe RepoKind)
v GetFlags
flags -> GetFlags
flags { getSourceRepository :: Flag (Maybe RepoKind)
getSourceRepository = Flag (Maybe RepoKind)
v })
        (forall b a.
Monoid b =>
String
-> ReadE b
-> b
-> (b -> [Maybe String])
-> MkOptDescr (a -> b) (b -> a -> a) a
optArg String
"[head|this|...]" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (forall a b. a -> b -> a
const String
"invalid source-repository")
                                              (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. a -> Flag a
toFlag forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just) forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                                  (forall a. a -> Flag a
Flag forall a. Maybe a
Nothing)
                                  (forall a b. (a -> b) -> [a] -> [b]
map (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Show a => a -> String
show) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Flag a -> [a]
flagToList))

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"index-state"]
          (String
"Use source package index state as it existed at a previous time. " forall a. [a] -> [a] -> [a]
++
           String
"Accepts unix-timestamps (e.g. '@1474732068'), ISO8601 UTC timestamps " forall a. [a] -> [a] -> [a]
++
           String
"(e.g. '2016-09-24T17:47:48Z'), or 'HEAD' (default: 'HEAD'). " forall a. [a] -> [a] -> [a]
++
           String
"This determines which package versions are available as well as " forall a. [a] -> [a] -> [a]
++
           String
".cabal file revision is selected (unless --pristine is used).")
          GetFlags -> Flag TotalIndexState
getIndexState (\Flag TotalIndexState
v GetFlags
flags -> GetFlags
flags { getIndexState :: Flag TotalIndexState
getIndexState = Flag TotalIndexState
v })
          (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"STATE" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ String
"index-state must be a  " forall a. [a] -> [a] -> [a]
++
                                       String
"unix-timestamps (e.g. '@1474732068'), " forall a. [a] -> [a] -> [a]
++
                                       String
"a ISO8601 UTC timestamp " forall a. [a] -> [a] -> [a]
++
                                       String
"(e.g. '2016-09-24T17:47:48Z'), or 'HEAD'")
                                      (forall a. a -> Flag a
toFlag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                          (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> String
prettyShow))

       , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"only-package-description"]
           String
"Unpack only the package description file."
           GetFlags -> Flag Bool
getOnlyPkgDescr (\Flag Bool
v GetFlags
flags -> GetFlags
flags { getOnlyPkgDescr :: Flag Bool
getOnlyPkgDescr = Flag Bool
v })
           forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

       , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"package-description-only"]
           String
"A synonym for --only-package-description."
           GetFlags -> Flag Bool
getOnlyPkgDescr (\Flag Bool
v GetFlags
flags -> GetFlags
flags { getOnlyPkgDescr :: Flag Bool
getOnlyPkgDescr = Flag Bool
v })
           forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

       , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"pristine"]
           (String
"Unpack the original pristine tarball, rather than updating the "
           forall a. [a] -> [a] -> [a]
++ String
".cabal file with the latest revision from the package archive.")
           GetFlags -> Flag Bool
getPristine (\Flag Bool
v GetFlags
flags -> GetFlags
flags { getPristine :: Flag Bool
getPristine = Flag Bool
v })
           forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg
       ]
  }

-- | List of lines describing command @get@.
descriptionOfGetCommand :: [String]
descriptionOfGetCommand :: [String]
descriptionOfGetCommand =
  [ String
"Creates a local copy of a package's source code. By default it gets the source"
  , String
"tarball and unpacks it in a local subdirectory. Alternatively, with -s it will"
  , String
"get the code from the source repository specified by the package."
  ]

-- | Notes for the command @get@.
notesOfGetCommand
  :: String    -- ^ Either @"get"@ or @"unpack"@.
  -> String    -- ^ E.g. @"cabal"@.
  -> [String]  -- ^ List of lines.
notesOfGetCommand :: String -> String -> [String]
notesOfGetCommand String
cmd String
pname =
  [ String
"Examples:"
  , String
"  " forall a. [a] -> [a] -> [a]
++ [String] -> String
unwords [ String
pname, String
cmd, String
"hlint" ]
  , String
"    Download the latest stable version of hlint;"
  , String
"  " forall a. [a] -> [a] -> [a]
++ [String] -> String
unwords [ String
pname, String
cmd, String
"lens --source-repository=head" ]
  , String
"    Download the source repository of lens (i.e. git clone from github)."
  ]

-- 'cabal unpack' is a deprecated alias for 'cabal get'.
unpackCommand :: CommandUI GetFlags
unpackCommand :: CommandUI GetFlags
unpackCommand = CommandUI GetFlags
getCommand
  { commandName :: String
commandName        = String
"unpack"
  , commandSynopsis :: String
commandSynopsis    = String
synopsis
  , commandNotes :: Maybe (String -> String)
commandNotes       = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \ String
pname -> [String] -> String
unlines forall a b. (a -> b) -> a -> b
$
      String -> String -> [String]
notesOfGetCommand String
"unpack" String
pname
  , commandUsage :: String -> String
commandUsage       = String -> String -> String
usagePackages String
"unpack"
  }
  where
  synopsis :: String
synopsis = String
"Deprecated alias for 'get'."

instance Monoid GetFlags where
  mempty :: GetFlags
mempty = forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: GetFlags -> GetFlags -> GetFlags
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup GetFlags where
  <> :: GetFlags -> GetFlags -> GetFlags
(<>) = forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend

-- ------------------------------------------------------------
-- * List flags
-- ------------------------------------------------------------

data ListFlags = ListFlags
    { ListFlags -> Flag Bool
listInstalled       :: Flag Bool
    , ListFlags -> Flag Bool
listSimpleOutput    :: Flag Bool
    , ListFlags -> Flag Bool
listCaseInsensitive :: Flag Bool
    , ListFlags -> Flag Verbosity
listVerbosity       :: Flag Verbosity
    , ListFlags -> [Maybe PackageDB]
listPackageDBs      :: [Maybe PackageDB]
    , ListFlags -> Flag String
listHcPath          :: Flag FilePath
    }
  deriving forall x. Rep ListFlags x -> ListFlags
forall x. ListFlags -> Rep ListFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListFlags x -> ListFlags
$cfrom :: forall x. ListFlags -> Rep ListFlags x
Generic

defaultListFlags :: ListFlags
defaultListFlags :: ListFlags
defaultListFlags = ListFlags
    { listInstalled :: Flag Bool
listInstalled       = forall a. a -> Flag a
Flag Bool
False
    , listSimpleOutput :: Flag Bool
listSimpleOutput    = forall a. a -> Flag a
Flag Bool
False
    , listCaseInsensitive :: Flag Bool
listCaseInsensitive = forall a. a -> Flag a
Flag Bool
True
    , listVerbosity :: Flag Verbosity
listVerbosity       = forall a. a -> Flag a
toFlag Verbosity
normal
    , listPackageDBs :: [Maybe PackageDB]
listPackageDBs      = []
    , listHcPath :: Flag String
listHcPath          = forall a. Monoid a => a
mempty
    }

listCommand  :: CommandUI ListFlags
listCommand :: CommandUI ListFlags
listCommand = CommandUI {
    commandName :: String
commandName         = String
"list",
    commandSynopsis :: String
commandSynopsis     = String
"List packages matching a search string.",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
         String
"List all packages, or all packages matching one of the search"
      forall a. [a] -> [a] -> [a]
++ String
" strings.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"Use the package database specified with --package-db. "
      forall a. [a] -> [a] -> [a]
++ String
"If not specified, use the user package database.\n",
    commandNotes :: Maybe (String -> String)
commandNotes        = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname ->
         String
"Examples:\n"
      forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" list pandoc\n"
      forall a. [a] -> [a] -> [a]
++ String
"    Will find pandoc, pandoc-citeproc, pandoc-lens, ...\n",
    commandUsage :: String -> String
commandUsage        = String -> [String] -> String -> String
usageAlternatives String
"list" [ String
"[FLAGS]"
                                                   , String
"[FLAGS] STRINGS"],
    commandDefaultFlags :: ListFlags
commandDefaultFlags = ListFlags
defaultListFlags,
    commandOptions :: ShowOrParseArgs -> [OptionField ListFlags]
commandOptions      = forall a b. a -> b -> a
const [OptionField ListFlags]
listOptions
  }

listOptions :: [OptionField ListFlags]
listOptions :: [OptionField ListFlags]
listOptions =
    [ forall flags.
(flags -> Flag Verbosity)
-> (Flag Verbosity -> flags -> flags) -> OptionField flags
optionVerbosity ListFlags -> Flag Verbosity
listVerbosity (\Flag Verbosity
v ListFlags
flags -> ListFlags
flags { listVerbosity :: Flag Verbosity
listVerbosity = Flag Verbosity
v })

    , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"installed"]
        String
"Only print installed packages"
        ListFlags -> Flag Bool
listInstalled (\Flag Bool
v ListFlags
flags -> ListFlags
flags { listInstalled :: Flag Bool
listInstalled = Flag Bool
v })
        forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

    , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"simple-output"]
        String
"Print in a easy-to-parse format"
        ListFlags -> Flag Bool
listSimpleOutput (\Flag Bool
v ListFlags
flags -> ListFlags
flags { listSimpleOutput :: Flag Bool
listSimpleOutput = Flag Bool
v })
        forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg
    , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'i'] [String
"ignore-case"]
        String
"Ignore case distinctions"
        ListFlags -> Flag Bool
listCaseInsensitive (\Flag Bool
v ListFlags
flags -> ListFlags
flags { listCaseInsensitive :: Flag Bool
listCaseInsensitive = Flag Bool
v })
        (forall a.
OptFlags
-> OptFlags -> MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
boolOpt' ([Char
'i'], [String
"ignore-case"]) ([Char
'I'], [String
"strict-case"]))

    , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"" [String
"package-db"]
      (   String
"Append the given package database to the list of package"
       forall a. [a] -> [a] -> [a]
++ String
" databases used (to satisfy dependencies and register into)."
       forall a. [a] -> [a] -> [a]
++ String
" May be a specific file, 'global' or 'user'. The initial list"
       forall a. [a] -> [a] -> [a]
++ String
" is ['global'], ['global', 'user'],"
       forall a. [a] -> [a] -> [a]
++ String
" depending on context. Use 'clear' to reset the list to empty."
       forall a. [a] -> [a] -> [a]
++ String
" See the user guide for details.")
      ListFlags -> [Maybe PackageDB]
listPackageDBs (\[Maybe PackageDB]
v ListFlags
flags -> ListFlags
flags { listPackageDBs :: [Maybe PackageDB]
listPackageDBs = [Maybe PackageDB]
v })
      (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"DB" String -> [Maybe PackageDB]
readPackageDbList [Maybe PackageDB] -> [String]
showPackageDbList)

    , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"w" [String
"with-compiler"]
      String
"give the path to a particular compiler"
      ListFlags -> Flag String
listHcPath (\Flag String
v ListFlags
flags -> ListFlags
flags { listHcPath :: Flag String
listHcPath = Flag String
v })
      (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"PATH")
    ]

listNeedsCompiler :: ListFlags -> Bool
listNeedsCompiler :: ListFlags -> Bool
listNeedsCompiler ListFlags
f =
    forall b a. b -> (a -> b) -> Flag a -> b
flagElim Bool
False (forall a b. a -> b -> a
const Bool
True) (ListFlags -> Flag String
listHcPath ListFlags
f)
    Bool -> Bool -> Bool
|| forall a. a -> Flag a -> a
fromFlagOrDefault Bool
False (ListFlags -> Flag Bool
listInstalled ListFlags
f)

instance Monoid ListFlags where
  mempty :: ListFlags
mempty = forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: ListFlags -> ListFlags -> ListFlags
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup ListFlags where
  <> :: ListFlags -> ListFlags -> ListFlags
(<>) = forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend

-- ------------------------------------------------------------
-- * Info flags
-- ------------------------------------------------------------

data InfoFlags = InfoFlags {
    InfoFlags -> Flag Verbosity
infoVerbosity  :: Flag Verbosity,
    InfoFlags -> [Maybe PackageDB]
infoPackageDBs :: [Maybe PackageDB]
  } deriving forall x. Rep InfoFlags x -> InfoFlags
forall x. InfoFlags -> Rep InfoFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InfoFlags x -> InfoFlags
$cfrom :: forall x. InfoFlags -> Rep InfoFlags x
Generic

defaultInfoFlags :: InfoFlags
defaultInfoFlags :: InfoFlags
defaultInfoFlags = InfoFlags {
    infoVerbosity :: Flag Verbosity
infoVerbosity  = forall a. a -> Flag a
toFlag Verbosity
normal,
    infoPackageDBs :: [Maybe PackageDB]
infoPackageDBs = []
  }

infoCommand  :: CommandUI InfoFlags
infoCommand :: CommandUI InfoFlags
infoCommand = CommandUI {
    commandName :: String
commandName         = String
"info",
    commandSynopsis :: String
commandSynopsis     = String
"Display detailed information about a particular package.",
    commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
      String
"Use the package database specified with --package-db. "
      forall a. [a] -> [a] -> [a]
++ String
"If not specified, use the user package database.\n",
    commandNotes :: Maybe (String -> String)
commandNotes        = forall a. Maybe a
Nothing,
    commandUsage :: String -> String
commandUsage        = String -> [String] -> String -> String
usageAlternatives String
"info" [String
"[FLAGS] PACKAGES"],
    commandDefaultFlags :: InfoFlags
commandDefaultFlags = InfoFlags
defaultInfoFlags,
    commandOptions :: ShowOrParseArgs -> [OptionField InfoFlags]
commandOptions      = \ShowOrParseArgs
_ -> [
        forall flags.
(flags -> Flag Verbosity)
-> (Flag Verbosity -> flags -> flags) -> OptionField flags
optionVerbosity InfoFlags -> Flag Verbosity
infoVerbosity (\Flag Verbosity
v InfoFlags
flags -> InfoFlags
flags { infoVerbosity :: Flag Verbosity
infoVerbosity = Flag Verbosity
v })

        , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"" [String
"package-db"]
          (   String
"Append the given package database to the list of package"
           forall a. [a] -> [a] -> [a]
++ String
" databases used (to satisfy dependencies and register into)."
           forall a. [a] -> [a] -> [a]
++ String
" May be a specific file, 'global' or 'user'. The initial list"
           forall a. [a] -> [a] -> [a]
++ String
" is ['global'], ['global', 'user'],"
           forall a. [a] -> [a] -> [a]
++ String
" depending on context. Use 'clear' to reset the list to empty."
           forall a. [a] -> [a] -> [a]
++ String
" See the user guide for details.")
          InfoFlags -> [Maybe PackageDB]
infoPackageDBs (\[Maybe PackageDB]
v InfoFlags
flags -> InfoFlags
flags { infoPackageDBs :: [Maybe PackageDB]
infoPackageDBs = [Maybe PackageDB]
v })
          (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"DB" String -> [Maybe PackageDB]
readPackageDbList [Maybe PackageDB] -> [String]
showPackageDbList)

        ]
  }

instance Monoid InfoFlags where
  mempty :: InfoFlags
mempty = forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: InfoFlags -> InfoFlags -> InfoFlags
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup InfoFlags where
  <> :: InfoFlags -> InfoFlags -> InfoFlags
(<>) = forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend

-- ------------------------------------------------------------
-- * Install flags
-- ------------------------------------------------------------

-- | Install takes the same flags as configure along with a few extras.
--
data InstallFlags = InstallFlags {
    InstallFlags -> Flag Bool
installDocumentation    :: Flag Bool,
    InstallFlags -> Flag PathTemplate
installHaddockIndex     :: Flag PathTemplate,
    InstallFlags -> Flag CopyDest
installDest             :: Flag Cabal.CopyDest,
    InstallFlags -> Flag Bool
installDryRun           :: Flag Bool,
    InstallFlags -> Flag Bool
installOnlyDownload     :: Flag Bool,
    InstallFlags -> Flag Int
installMaxBackjumps     :: Flag Int,
    InstallFlags -> Flag ReorderGoals
installReorderGoals     :: Flag ReorderGoals,
    InstallFlags -> Flag CountConflicts
installCountConflicts   :: Flag CountConflicts,
    InstallFlags -> Flag FineGrainedConflicts
installFineGrainedConflicts :: Flag FineGrainedConflicts,
    InstallFlags -> Flag MinimizeConflictSet
installMinimizeConflictSet :: Flag MinimizeConflictSet,
    InstallFlags -> Flag IndependentGoals
installIndependentGoals :: Flag IndependentGoals,
    InstallFlags -> Flag PreferOldest
installPreferOldest     :: Flag PreferOldest,
    InstallFlags -> Flag ShadowPkgs
installShadowPkgs       :: Flag ShadowPkgs,
    InstallFlags -> Flag StrongFlags
installStrongFlags      :: Flag StrongFlags,
    InstallFlags -> Flag AllowBootLibInstalls
installAllowBootLibInstalls :: Flag AllowBootLibInstalls,
    InstallFlags -> Flag OnlyConstrained
installOnlyConstrained  :: Flag OnlyConstrained,
    InstallFlags -> Flag Bool
installReinstall        :: Flag Bool,
    InstallFlags -> Flag AvoidReinstalls
installAvoidReinstalls  :: Flag AvoidReinstalls,
    InstallFlags -> Flag Bool
installOverrideReinstall :: Flag Bool,
    InstallFlags -> Flag Bool
installUpgradeDeps      :: Flag Bool,
    InstallFlags -> Flag Bool
installOnly             :: Flag Bool,
    InstallFlags -> Flag Bool
installOnlyDeps         :: Flag Bool,
    InstallFlags -> Flag TotalIndexState
installIndexState       :: Flag TotalIndexState,
    InstallFlags -> Flag String
installRootCmd          :: Flag String,
    InstallFlags -> NubList PathTemplate
installSummaryFile      :: NubList PathTemplate,
    InstallFlags -> Flag PathTemplate
installLogFile          :: Flag PathTemplate,
    InstallFlags -> Flag ReportLevel
installBuildReports     :: Flag ReportLevel,
    InstallFlags -> Flag Bool
installReportPlanningFailure :: Flag Bool,
    -- Note: symlink-bindir is no longer used by v2-install and can be removed
    -- when removing v1 commands
    InstallFlags -> Flag String
installSymlinkBinDir    :: Flag FilePath,
    InstallFlags -> Flag Bool
installPerComponent     :: Flag Bool,
    InstallFlags -> Flag (Maybe Int)
installNumJobs          :: Flag (Maybe Int),
    InstallFlags -> Flag Bool
installKeepGoing        :: Flag Bool,
    InstallFlags -> Flag Bool
installRunTests         :: Flag Bool,
    InstallFlags -> Flag Bool
installOfflineMode      :: Flag Bool
  }
  deriving (InstallFlags -> InstallFlags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InstallFlags -> InstallFlags -> Bool
$c/= :: InstallFlags -> InstallFlags -> Bool
== :: InstallFlags -> InstallFlags -> Bool
$c== :: InstallFlags -> InstallFlags -> Bool
Eq, Int -> InstallFlags -> String -> String
[InstallFlags] -> String -> String
InstallFlags -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [InstallFlags] -> String -> String
$cshowList :: [InstallFlags] -> String -> String
show :: InstallFlags -> String
$cshow :: InstallFlags -> String
showsPrec :: Int -> InstallFlags -> String -> String
$cshowsPrec :: Int -> InstallFlags -> String -> String
Show, forall x. Rep InstallFlags x -> InstallFlags
forall x. InstallFlags -> Rep InstallFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InstallFlags x -> InstallFlags
$cfrom :: forall x. InstallFlags -> Rep InstallFlags x
Generic)

instance Binary InstallFlags

defaultInstallFlags :: InstallFlags
defaultInstallFlags :: InstallFlags
defaultInstallFlags = InstallFlags {
    installDocumentation :: Flag Bool
installDocumentation   = forall a. a -> Flag a
Flag Bool
False,
    installHaddockIndex :: Flag PathTemplate
installHaddockIndex    = forall a. a -> Flag a
Flag PathTemplate
docIndexFile,
    installDest :: Flag CopyDest
installDest            = forall a. a -> Flag a
Flag CopyDest
Cabal.NoCopyDest,
    installDryRun :: Flag Bool
installDryRun          = forall a. a -> Flag a
Flag Bool
False,
    installOnlyDownload :: Flag Bool
installOnlyDownload    = forall a. a -> Flag a
Flag Bool
False,
    installMaxBackjumps :: Flag Int
installMaxBackjumps    = forall a. a -> Flag a
Flag Int
defaultMaxBackjumps,
    installReorderGoals :: Flag ReorderGoals
installReorderGoals    = forall a. a -> Flag a
Flag (Bool -> ReorderGoals
ReorderGoals Bool
False),
    installCountConflicts :: Flag CountConflicts
installCountConflicts  = forall a. a -> Flag a
Flag (Bool -> CountConflicts
CountConflicts Bool
True),
    installFineGrainedConflicts :: Flag FineGrainedConflicts
installFineGrainedConflicts = forall a. a -> Flag a
Flag (Bool -> FineGrainedConflicts
FineGrainedConflicts Bool
True),
    installMinimizeConflictSet :: Flag MinimizeConflictSet
installMinimizeConflictSet = forall a. a -> Flag a
Flag (Bool -> MinimizeConflictSet
MinimizeConflictSet Bool
False),
    installIndependentGoals :: Flag IndependentGoals
installIndependentGoals= forall a. a -> Flag a
Flag (Bool -> IndependentGoals
IndependentGoals Bool
False),
    installPreferOldest :: Flag PreferOldest
installPreferOldest    = forall a. a -> Flag a
Flag (Bool -> PreferOldest
PreferOldest Bool
False),
    installShadowPkgs :: Flag ShadowPkgs
installShadowPkgs      = forall a. a -> Flag a
Flag (Bool -> ShadowPkgs
ShadowPkgs Bool
False),
    installStrongFlags :: Flag StrongFlags
installStrongFlags     = forall a. a -> Flag a
Flag (Bool -> StrongFlags
StrongFlags Bool
False),
    installAllowBootLibInstalls :: Flag AllowBootLibInstalls
installAllowBootLibInstalls = forall a. a -> Flag a
Flag (Bool -> AllowBootLibInstalls
AllowBootLibInstalls Bool
False),
    installOnlyConstrained :: Flag OnlyConstrained
installOnlyConstrained = forall a. a -> Flag a
Flag OnlyConstrained
OnlyConstrainedNone,
    installReinstall :: Flag Bool
installReinstall       = forall a. a -> Flag a
Flag Bool
False,
    installAvoidReinstalls :: Flag AvoidReinstalls
installAvoidReinstalls = forall a. a -> Flag a
Flag (Bool -> AvoidReinstalls
AvoidReinstalls Bool
False),
    installOverrideReinstall :: Flag Bool
installOverrideReinstall = forall a. a -> Flag a
Flag Bool
False,
    installUpgradeDeps :: Flag Bool
installUpgradeDeps     = forall a. a -> Flag a
Flag Bool
False,
    installOnly :: Flag Bool
installOnly            = forall a. a -> Flag a
Flag Bool
False,
    installOnlyDeps :: Flag Bool
installOnlyDeps        = forall a. a -> Flag a
Flag Bool
False,
    installIndexState :: Flag TotalIndexState
installIndexState      = forall a. Monoid a => a
mempty,
    installRootCmd :: Flag String
installRootCmd         = forall a. Monoid a => a
mempty,
    installSummaryFile :: NubList PathTemplate
installSummaryFile     = forall a. Monoid a => a
mempty,
    installLogFile :: Flag PathTemplate
installLogFile         = forall a. Monoid a => a
mempty,
    installBuildReports :: Flag ReportLevel
installBuildReports    = forall a. a -> Flag a
Flag ReportLevel
NoReports,
    installReportPlanningFailure :: Flag Bool
installReportPlanningFailure = forall a. a -> Flag a
Flag Bool
False,
    installSymlinkBinDir :: Flag String
installSymlinkBinDir   = forall a. Monoid a => a
mempty,
    installPerComponent :: Flag Bool
installPerComponent    = forall a. a -> Flag a
Flag Bool
True,
    installNumJobs :: Flag (Maybe Int)
installNumJobs         = forall a. Monoid a => a
mempty,
    installKeepGoing :: Flag Bool
installKeepGoing       = forall a. a -> Flag a
Flag Bool
False,
    installRunTests :: Flag Bool
installRunTests        = forall a. Monoid a => a
mempty,
    installOfflineMode :: Flag Bool
installOfflineMode     = forall a. a -> Flag a
Flag Bool
False
  }
  where
    docIndexFile :: PathTemplate
docIndexFile = String -> PathTemplate
toPathTemplate (String
"$datadir" String -> String -> String
</> String
"doc"
                                   String -> String -> String
</> String
"$arch-$os-$compiler" String -> String -> String
</> String
"index.html")

defaultMaxBackjumps :: Int
defaultMaxBackjumps :: Int
defaultMaxBackjumps = Int
4000

defaultSolver :: PreSolver
defaultSolver :: PreSolver
defaultSolver = PreSolver
AlwaysModular

allSolvers :: String
allSolvers :: String
allSolvers = forall a. [a] -> [[a]] -> [a]
intercalate String
", " (forall a b. (a -> b) -> [a] -> [b]
map forall a. Pretty a => a -> String
prettyShow ([forall a. Bounded a => a
minBound .. forall a. Bounded a => a
maxBound] :: [PreSolver]))

installCommand :: CommandUI ( ConfigFlags, ConfigExFlags, InstallFlags
                            , HaddockFlags, TestFlags, BenchmarkFlags
                            )
installCommand :: CommandUI
  (ConfigFlags, ConfigExFlags, InstallFlags, HaddockFlags, TestFlags,
   BenchmarkFlags)
installCommand = CommandUI {
  commandName :: String
commandName         = String
"install",
  commandSynopsis :: String
commandSynopsis     = String
"Install packages.",
  commandUsage :: String -> String
commandUsage        = String -> [String] -> String -> String
usageAlternatives String
"v1-install" [ String
"[FLAGS]"
                                                    , String
"[FLAGS] PACKAGES"
                                                    ],
  commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
        String
"Installs one or more packages. By default, the installed package"
     forall a. [a] -> [a] -> [a]
++ String
" will be registered in the user's package database."
     forall a. [a] -> [a] -> [a]
++ String
"\n"
     forall a. [a] -> [a] -> [a]
++ String
"If PACKAGES are specified, downloads and installs those packages."
     forall a. [a] -> [a] -> [a]
++ String
" Otherwise, install the package in the current directory (and/or its"
     forall a. [a] -> [a] -> [a]
++ String
" dependencies) (there must be exactly one .cabal file in the current"
     forall a. [a] -> [a] -> [a]
++ String
" directory).\n"
     forall a. [a] -> [a] -> [a]
++ String
"\n"
     forall a. [a] -> [a] -> [a]
++ String
"The flags to `v1-install` are saved and"
     forall a. [a] -> [a] -> [a]
++ String
" affect future commands such as `v1-build` and `v1-repl`. See the help for"
     forall a. [a] -> [a] -> [a]
++ String
" `v1-configure` for a list of commands being affected.\n"
     forall a. [a] -> [a] -> [a]
++ String
"\n"
     forall a. [a] -> [a] -> [a]
++ String
"Installed executables will by default"
     forall a. [a] -> [a] -> [a]
++ String
" be put into `~/.local/bin/`."
     forall a. [a] -> [a] -> [a]
++ String
" If you want installed executable to be available globally, make"
     forall a. [a] -> [a] -> [a]
++ String
" sure that the PATH environment variable contains that directory.\n"
     forall a. [a] -> [a] -> [a]
++ String
"\n",
  commandNotes :: Maybe (String -> String)
commandNotes        = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname ->
        ( case forall flags. CommandUI flags -> Maybe (String -> String)
commandNotes
               forall a b. (a -> b) -> a -> b
$ ProgramDb -> CommandUI ConfigFlags
Cabal.configureCommand ProgramDb
defaultProgramDb
          of Just String -> String
desc -> String -> String
desc String
pname forall a. [a] -> [a] -> [a]
++ String
"\n"
             Maybe (String -> String)
Nothing   -> String
""
        )
     forall a. [a] -> [a] -> [a]
++ String
"Examples:\n"
     forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-install                 "
     forall a. [a] -> [a] -> [a]
++ String
"    Package in the current directory\n"
     forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-install foo             "
     forall a. [a] -> [a] -> [a]
++ String
"    Package from the hackage server\n"
     forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-install foo-1.0         "
     forall a. [a] -> [a] -> [a]
++ String
"    Specific version of a package\n"
     forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-install 'foo < 2'       "
     forall a. [a] -> [a] -> [a]
++ String
"    Constrained package version\n"
     forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-install haddock --bindir=$HOME/hask-bin/ --datadir=$HOME/hask-data/\n"
     forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ (forall a b. (a -> b) -> [a] -> [b]
map (forall a b. a -> b -> a
const Char
' ') String
pname)
                      forall a. [a] -> [a] -> [a]
++ String
"                         "
     forall a. [a] -> [a] -> [a]
++ String
"    Change installation destination\n",
  commandDefaultFlags :: (ConfigFlags, ConfigExFlags, InstallFlags, HaddockFlags, TestFlags,
 BenchmarkFlags)
commandDefaultFlags = (forall a. Monoid a => a
mempty, forall a. Monoid a => a
mempty, forall a. Monoid a => a
mempty, forall a. Monoid a => a
mempty, forall a. Monoid a => a
mempty, forall a. Monoid a => a
mempty),
  commandOptions :: ShowOrParseArgs
-> [OptionField
      (ConfigFlags, ConfigExFlags, InstallFlags, HaddockFlags, TestFlags,
       BenchmarkFlags)]
commandOptions      = \ShowOrParseArgs
showOrParseArgs ->
       forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions forall {a} {b} {c} {d} {e} {f}. (a, b, c, d, e, f) -> a
get1 forall {a} {a} {b} {c} {d} {e} {f}.
a -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
set1
       -- Note: [Hidden Flags]
       -- hide "constraint", "dependency", and
       -- "exact-configuration" from the configure options.
       (forall a. (a -> Bool) -> [a] -> [a]
filter ((forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [String
"constraint", String
"dependency"
                           , String
"exact-configuration"])
                forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. OptionField a -> String
optionName) forall a b. (a -> b) -> a -> b
$
                              ShowOrParseArgs -> [OptionField ConfigFlags]
configureOptions   ShowOrParseArgs
showOrParseArgs)
    forall a. [a] -> [a] -> [a]
++ forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions forall {a} {b} {c} {d} {e} {f}. (a, b, c, d, e, f) -> b
get2 forall {b} {a} {b} {c} {d} {e} {f}.
b -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
set2 (ShowOrParseArgs -> ConstraintSource -> [OptionField ConfigExFlags]
configureExOptions ShowOrParseArgs
showOrParseArgs ConstraintSource
ConstraintSourceCommandlineFlag)
    forall a. [a] -> [a] -> [a]
++ forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions forall {a} {b} {c} {d} {e} {f}. (a, b, c, d, e, f) -> c
get3 forall {c} {a} {b} {c} {d} {e} {f}.
c -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
set3
       -- hide "target-package-db" flag from the
       -- install options.
       (forall a. (a -> Bool) -> [a] -> [a]
filter ((forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [String
"target-package-db"])
                forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. OptionField a -> String
optionName) forall a b. (a -> b) -> a -> b
$
                              ShowOrParseArgs -> [OptionField InstallFlags]
installOptions     ShowOrParseArgs
showOrParseArgs)
    forall a. [a] -> [a] -> [a]
++ forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions forall {a} {b} {c} {d} {e} {f}. (a, b, c, d, e, f) -> d
get4 forall {d} {a} {b} {c} {d} {e} {f}.
d -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
set4 (ShowOrParseArgs -> [OptionField HaddockFlags]
haddockOptions     ShowOrParseArgs
showOrParseArgs)
    forall a. [a] -> [a] -> [a]
++ forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions forall {a} {b} {c} {d} {e} {f}. (a, b, c, d, e, f) -> e
get5 forall {e} {a} {b} {c} {d} {e} {f}.
e -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
set5 (ShowOrParseArgs -> [OptionField TestFlags]
testOptions        ShowOrParseArgs
showOrParseArgs)
    forall a. [a] -> [a] -> [a]
++ forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions forall {a} {b} {c} {d} {e} {f}. (a, b, c, d, e, f) -> f
get6 forall {f} {a} {b} {c} {d} {e} {f}.
f -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
set6 (ShowOrParseArgs -> [OptionField BenchmarkFlags]
benchmarkOptions   ShowOrParseArgs
showOrParseArgs)
  }
  where
    get1 :: (a, b, c, d, e, f) -> a
get1 (a
a,b
_,c
_,d
_,e
_,f
_) = a
a; set1 :: a -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
set1 a
a (a
_,b
b,c
c,d
d,e
e,f
f) = (a
a,b
b,c
c,d
d,e
e,f
f)
    get2 :: (a, b, c, d, e, f) -> b
get2 (a
_,b
b,c
_,d
_,e
_,f
_) = b
b; set2 :: b -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
set2 b
b (a
a,b
_,c
c,d
d,e
e,f
f) = (a
a,b
b,c
c,d
d,e
e,f
f)
    get3 :: (a, b, c, d, e, f) -> c
get3 (a
_,b
_,c
c,d
_,e
_,f
_) = c
c; set3 :: c -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
set3 c
c (a
a,b
b,c
_,d
d,e
e,f
f) = (a
a,b
b,c
c,d
d,e
e,f
f)
    get4 :: (a, b, c, d, e, f) -> d
get4 (a
_,b
_,c
_,d
d,e
_,f
_) = d
d; set4 :: d -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
set4 d
d (a
a,b
b,c
c,d
_,e
e,f
f) = (a
a,b
b,c
c,d
d,e
e,f
f)
    get5 :: (a, b, c, d, e, f) -> e
get5 (a
_,b
_,c
_,d
_,e
e,f
_) = e
e; set5 :: e -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
set5 e
e (a
a,b
b,c
c,d
d,e
_,f
f) = (a
a,b
b,c
c,d
d,e
e,f
f)
    get6 :: (a, b, c, d, e, f) -> f
get6 (a
_,b
_,c
_,d
_,e
_,f
f) = f
f; set6 :: f -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)
set6 f
f (a
a,b
b,c
c,d
d,e
e,f
_) = (a
a,b
b,c
c,d
d,e
e,f
f)

haddockCommand :: CommandUI HaddockFlags
haddockCommand :: CommandUI HaddockFlags
haddockCommand = CommandUI HaddockFlags
Cabal.haddockCommand
  { commandUsage :: String -> String
commandUsage = String -> [String] -> String -> String
usageAlternatives String
"v1-haddock" forall a b. (a -> b) -> a -> b
$
      [ String
"[FLAGS]", String
"COMPONENTS [FLAGS]" ]
  }

filterHaddockArgs :: [String] -> Version -> [String]
filterHaddockArgs :: [String] -> Version -> [String]
filterHaddockArgs [String]
args Version
cabalLibVersion
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
2,Int
3,Int
0] = [String]
args_latest
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
2,Int
3,Int
0] = forall a. [a]
args_2_3_0
  | Bool
otherwise = [String]
args_latest
  where
    args_latest :: [String]
args_latest = [String]
args

    -- Cabal < 2.3 doesn't know about per-component haddock
    args_2_3_0 :: [a]
args_2_3_0 = []

filterHaddockFlags :: HaddockFlags -> Version -> HaddockFlags
filterHaddockFlags :: HaddockFlags -> Version -> HaddockFlags
filterHaddockFlags HaddockFlags
flags Version
cabalLibVersion
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
>= [Int] -> Version
mkVersion [Int
2,Int
3,Int
0] = HaddockFlags
flags_latest
  | Version
cabalLibVersion forall a. Ord a => a -> a -> Bool
< [Int] -> Version
mkVersion [Int
2,Int
3,Int
0] = HaddockFlags
flags_2_3_0
  | Bool
otherwise = HaddockFlags
flags_latest
  where
    flags_latest :: HaddockFlags
flags_latest = HaddockFlags
flags

    flags_2_3_0 :: HaddockFlags
flags_2_3_0 = HaddockFlags
flags_latest {
      -- Cabal < 2.3 doesn't know about per-component haddock
      haddockArgs :: [String]
haddockArgs = []
      }

haddockOptions :: ShowOrParseArgs -> [OptionField HaddockFlags]
haddockOptions :: ShowOrParseArgs -> [OptionField HaddockFlags]
haddockOptions ShowOrParseArgs
showOrParseArgs
  = [ OptionField HaddockFlags
opt { optionName :: String
optionName = String
"haddock-" forall a. [a] -> [a] -> [a]
++ String
name,
            optionDescr :: [OptDescr HaddockFlags]
optionDescr = [ forall a. (OptFlags -> OptFlags) -> OptDescr a -> OptDescr a
fmapOptFlags (\(String
_, [String]
lflags) -> ([], forall a b. (a -> b) -> [a] -> [b]
map (String
"haddock-" forall a. [a] -> [a] -> [a]
++) [String]
lflags)) OptDescr HaddockFlags
descr
                          | OptDescr HaddockFlags
descr <- forall a. OptionField a -> [OptDescr a]
optionDescr OptionField HaddockFlags
opt] }
    | OptionField HaddockFlags
opt <- forall flags.
CommandUI flags -> ShowOrParseArgs -> [OptionField flags]
commandOptions CommandUI HaddockFlags
Cabal.haddockCommand ShowOrParseArgs
showOrParseArgs
    , let name :: String
name = forall a. OptionField a -> String
optionName OptionField HaddockFlags
opt
    , String
name forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"hoogle", String
"html", String
"html-location"
                  ,String
"executables", String
"tests", String
"benchmarks", String
"all", String
"internal", String
"css"
                  ,String
"hyperlink-source", String
"quickjump", String
"hscolour-css"
                  ,String
"contents-location", String
"use-index", String
"for-hackage", String
"base-url", String
"lib"]
    ]

testOptions :: ShowOrParseArgs -> [OptionField TestFlags]
testOptions :: ShowOrParseArgs -> [OptionField TestFlags]
testOptions ShowOrParseArgs
showOrParseArgs
  = [ OptionField TestFlags
opt { optionName :: String
optionName = String -> String
prefixTest String
name,
            optionDescr :: [OptDescr TestFlags]
optionDescr = [ forall a. (OptFlags -> OptFlags) -> OptDescr a -> OptDescr a
fmapOptFlags (\(String
_, [String]
lflags) -> ([], forall a b. (a -> b) -> [a] -> [b]
map String -> String
prefixTest [String]
lflags)) OptDescr TestFlags
descr
                          | OptDescr TestFlags
descr <- forall a. OptionField a -> [OptDescr a]
optionDescr OptionField TestFlags
opt] }
    | OptionField TestFlags
opt <- forall flags.
CommandUI flags -> ShowOrParseArgs -> [OptionField flags]
commandOptions CommandUI TestFlags
Cabal.testCommand ShowOrParseArgs
showOrParseArgs
    , let name :: String
name = forall a. OptionField a -> String
optionName OptionField TestFlags
opt
    , String
name forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"log", String
"machine-log", String
"show-details", String
"keep-tix-files"
                  ,String
"fail-when-no-test-suites", String
"test-options", String
"test-option"
                  ,String
"test-wrapper"]
    ]
  where
    prefixTest :: String -> String
prefixTest String
name | String
"test-" forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` String
name = String
name
                    | Bool
otherwise = String
"test-" forall a. [a] -> [a] -> [a]
++ String
name

benchmarkOptions :: ShowOrParseArgs -> [OptionField BenchmarkFlags]
benchmarkOptions :: ShowOrParseArgs -> [OptionField BenchmarkFlags]
benchmarkOptions ShowOrParseArgs
showOrParseArgs
  = [ OptionField BenchmarkFlags
opt { optionName :: String
optionName = String -> String
prefixBenchmark String
name,
            optionDescr :: [OptDescr BenchmarkFlags]
optionDescr = [ forall a. (OptFlags -> OptFlags) -> OptDescr a -> OptDescr a
fmapOptFlags (\(String
_, [String]
lflags) -> ([], forall a b. (a -> b) -> [a] -> [b]
map String -> String
prefixBenchmark [String]
lflags)) OptDescr BenchmarkFlags
descr
                          | OptDescr BenchmarkFlags
descr <- forall a. OptionField a -> [OptDescr a]
optionDescr OptionField BenchmarkFlags
opt] }
    | OptionField BenchmarkFlags
opt <- forall flags.
CommandUI flags -> ShowOrParseArgs -> [OptionField flags]
commandOptions CommandUI BenchmarkFlags
Cabal.benchmarkCommand ShowOrParseArgs
showOrParseArgs
    , let name :: String
name = forall a. OptionField a -> String
optionName OptionField BenchmarkFlags
opt
    , String
name forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [String
"benchmark-options", String
"benchmark-option"]
    ]
  where
    prefixBenchmark :: String -> String
prefixBenchmark String
name | String
"benchmark-" forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` String
name = String
name
                         | Bool
otherwise = String
"benchmark-" forall a. [a] -> [a] -> [a]
++ String
name

fmapOptFlags :: (OptFlags -> OptFlags) -> OptDescr a -> OptDescr a
fmapOptFlags :: forall a. (OptFlags -> OptFlags) -> OptDescr a -> OptDescr a
fmapOptFlags OptFlags -> OptFlags
modify (ReqArg String
d OptFlags
f String
p ReadE (a -> a)
r a -> [String]
w)    = forall a.
String
-> OptFlags
-> String
-> ReadE (a -> a)
-> (a -> [String])
-> OptDescr a
ReqArg String
d (OptFlags -> OptFlags
modify OptFlags
f) String
p ReadE (a -> a)
r a -> [String]
w
fmapOptFlags OptFlags -> OptFlags
modify (OptArg String
d OptFlags
f String
p ReadE (a -> a)
r a -> a
i a -> [Maybe String]
w)  = forall a.
String
-> OptFlags
-> String
-> ReadE (a -> a)
-> (a -> a)
-> (a -> [Maybe String])
-> OptDescr a
OptArg String
d (OptFlags -> OptFlags
modify OptFlags
f) String
p ReadE (a -> a)
r a -> a
i a -> [Maybe String]
w
fmapOptFlags OptFlags -> OptFlags
modify (ChoiceOpt [(String, OptFlags, a -> a, a -> Bool)]
xs)        = forall a. [(String, OptFlags, a -> a, a -> Bool)] -> OptDescr a
ChoiceOpt [(String
d, OptFlags -> OptFlags
modify OptFlags
f, a -> a
i, a -> Bool
w) | (String
d, OptFlags
f, a -> a
i, a -> Bool
w) <- [(String, OptFlags, a -> a, a -> Bool)]
xs]
fmapOptFlags OptFlags -> OptFlags
modify (BoolOpt String
d OptFlags
f1 OptFlags
f2 Bool -> a -> a
r a -> Maybe Bool
w) = forall a.
String
-> OptFlags
-> OptFlags
-> (Bool -> a -> a)
-> (a -> Maybe Bool)
-> OptDescr a
BoolOpt String
d (OptFlags -> OptFlags
modify OptFlags
f1) (OptFlags -> OptFlags
modify OptFlags
f2) Bool -> a -> a
r a -> Maybe Bool
w

installOptions ::  ShowOrParseArgs -> [OptionField InstallFlags]
installOptions :: ShowOrParseArgs -> [OptionField InstallFlags]
installOptions ShowOrParseArgs
showOrParseArgs =
      [ forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"" [String
"documentation"]
          String
"building of documentation"
          InstallFlags -> Flag Bool
installDocumentation (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installDocumentation :: Flag Bool
installDocumentation = Flag Bool
v })
          (forall a.
String
-> String -> MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
boolOpt [] [])

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"doc-index-file"]
          String
"A central index of haddock API documentation (template cannot use $pkgid)"
          InstallFlags -> Flag PathTemplate
installHaddockIndex (\Flag PathTemplate
v InstallFlags
flags -> InstallFlags
flags { installHaddockIndex :: Flag PathTemplate
installHaddockIndex = Flag PathTemplate
v })
          (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"TEMPLATE" (forall a. a -> Flag a
toFlagforall b c a. (b -> c) -> (a -> b) -> a -> c
.String -> PathTemplate
toPathTemplate)
                              (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PathTemplate -> String
fromPathTemplate))

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"dry-run"]
          String
"Do not install anything, only print what would be installed."
          InstallFlags -> Flag Bool
installDryRun (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installDryRun :: Flag Bool
installDryRun = Flag Bool
v })
          forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"only-download"]
          String
"Do not build anything, only fetch the packages."
          InstallFlags -> Flag Bool
installOnlyDownload (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installOnlyDownload :: Flag Bool
installOnlyDownload = Flag Bool
v })
          forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"" [String
"target-package-db"]
         String
"package database to install into. Required when using ${pkgroot} prefix."
         InstallFlags -> Flag CopyDest
installDest (\Flag CopyDest
v InstallFlags
flags -> InstallFlags
flags { installDest :: Flag CopyDest
installDest = Flag CopyDest
v })
         (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"DATABASE" (forall a. (String -> a) -> ReadE a
succeedReadE (forall a. a -> Flag a
Flag forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> CopyDest
Cabal.CopyToDb))
                            (\Flag CopyDest
f -> case Flag CopyDest
f of Flag (Cabal.CopyToDb String
p) -> [String
p]; Flag CopyDest
_ -> []))
      ] forall a. [a] -> [a] -> [a]
++

      forall flags.
ShowOrParseArgs
-> (flags -> Flag Int)
-> (Flag Int -> flags -> flags)
-> (flags -> Flag ReorderGoals)
-> (Flag ReorderGoals -> flags -> flags)
-> (flags -> Flag CountConflicts)
-> (Flag CountConflicts -> flags -> flags)
-> (flags -> Flag FineGrainedConflicts)
-> (Flag FineGrainedConflicts -> flags -> flags)
-> (flags -> Flag MinimizeConflictSet)
-> (Flag MinimizeConflictSet -> flags -> flags)
-> (flags -> Flag IndependentGoals)
-> (Flag IndependentGoals -> flags -> flags)
-> (flags -> Flag PreferOldest)
-> (Flag PreferOldest -> flags -> flags)
-> (flags -> Flag ShadowPkgs)
-> (Flag ShadowPkgs -> flags -> flags)
-> (flags -> Flag StrongFlags)
-> (Flag StrongFlags -> flags -> flags)
-> (flags -> Flag AllowBootLibInstalls)
-> (Flag AllowBootLibInstalls -> flags -> flags)
-> (flags -> Flag OnlyConstrained)
-> (Flag OnlyConstrained -> flags -> flags)
-> [OptionField flags]
optionSolverFlags ShowOrParseArgs
showOrParseArgs
                        InstallFlags -> Flag Int
installMaxBackjumps     (\Flag Int
v InstallFlags
flags -> InstallFlags
flags { installMaxBackjumps :: Flag Int
installMaxBackjumps     = Flag Int
v })
                        InstallFlags -> Flag ReorderGoals
installReorderGoals     (\Flag ReorderGoals
v InstallFlags
flags -> InstallFlags
flags { installReorderGoals :: Flag ReorderGoals
installReorderGoals     = Flag ReorderGoals
v })
                        InstallFlags -> Flag CountConflicts
installCountConflicts   (\Flag CountConflicts
v InstallFlags
flags -> InstallFlags
flags { installCountConflicts :: Flag CountConflicts
installCountConflicts   = Flag CountConflicts
v })
                        InstallFlags -> Flag FineGrainedConflicts
installFineGrainedConflicts (\Flag FineGrainedConflicts
v InstallFlags
flags -> InstallFlags
flags { installFineGrainedConflicts :: Flag FineGrainedConflicts
installFineGrainedConflicts = Flag FineGrainedConflicts
v })
                        InstallFlags -> Flag MinimizeConflictSet
installMinimizeConflictSet (\Flag MinimizeConflictSet
v InstallFlags
flags -> InstallFlags
flags { installMinimizeConflictSet :: Flag MinimizeConflictSet
installMinimizeConflictSet = Flag MinimizeConflictSet
v })
                        InstallFlags -> Flag IndependentGoals
installIndependentGoals (\Flag IndependentGoals
v InstallFlags
flags -> InstallFlags
flags { installIndependentGoals :: Flag IndependentGoals
installIndependentGoals = Flag IndependentGoals
v })
                        InstallFlags -> Flag PreferOldest
installPreferOldest     (\Flag PreferOldest
v InstallFlags
flags -> InstallFlags
flags { installPreferOldest :: Flag PreferOldest
installPreferOldest = Flag PreferOldest
v })
                        InstallFlags -> Flag ShadowPkgs
installShadowPkgs       (\Flag ShadowPkgs
v InstallFlags
flags -> InstallFlags
flags { installShadowPkgs :: Flag ShadowPkgs
installShadowPkgs       = Flag ShadowPkgs
v })
                        InstallFlags -> Flag StrongFlags
installStrongFlags      (\Flag StrongFlags
v InstallFlags
flags -> InstallFlags
flags { installStrongFlags :: Flag StrongFlags
installStrongFlags      = Flag StrongFlags
v })
                        InstallFlags -> Flag AllowBootLibInstalls
installAllowBootLibInstalls (\Flag AllowBootLibInstalls
v InstallFlags
flags -> InstallFlags
flags { installAllowBootLibInstalls :: Flag AllowBootLibInstalls
installAllowBootLibInstalls = Flag AllowBootLibInstalls
v })
                        InstallFlags -> Flag OnlyConstrained
installOnlyConstrained  (\Flag OnlyConstrained
v InstallFlags
flags -> InstallFlags
flags { installOnlyConstrained :: Flag OnlyConstrained
installOnlyConstrained  = Flag OnlyConstrained
v }) forall a. [a] -> [a] -> [a]
++

      [ forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"reinstall"]
          String
"Install even if it means installing the same version again."
          InstallFlags -> Flag Bool
installReinstall (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installReinstall :: Flag Bool
installReinstall = Flag Bool
v })
          (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"avoid-reinstalls"]
          String
"Do not select versions that would destructively overwrite installed packages."
          (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. BooleanFlag a => a -> Bool
asBool forall b c a. (b -> c) -> (a -> b) -> a -> c
. InstallFlags -> Flag AvoidReinstalls
installAvoidReinstalls)
          (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installAvoidReinstalls :: Flag AvoidReinstalls
installAvoidReinstalls = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> AvoidReinstalls
AvoidReinstalls Flag Bool
v })
          (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"force-reinstalls"]
          String
"Reinstall packages even if they will most likely break other installed packages."
          InstallFlags -> Flag Bool
installOverrideReinstall (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installOverrideReinstall :: Flag Bool
installOverrideReinstall = Flag Bool
v })
          (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"upgrade-dependencies"]
          String
"Pick the latest version for all dependencies, rather than trying to pick an installed version."
          InstallFlags -> Flag Bool
installUpgradeDeps (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installUpgradeDeps :: Flag Bool
installUpgradeDeps = Flag Bool
v })
          (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"only-dependencies"]
          String
"Install only the dependencies necessary to build the given packages"
          InstallFlags -> Flag Bool
installOnlyDeps (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installOnlyDeps :: Flag Bool
installOnlyDeps = Flag Bool
v })
          (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"dependencies-only"]
          String
"A synonym for --only-dependencies"
          InstallFlags -> Flag Bool
installOnlyDeps (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installOnlyDeps :: Flag Bool
installOnlyDeps = Flag Bool
v })
          (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"index-state"]
          (String
"Use source package index state as it existed at a previous time. " forall a. [a] -> [a] -> [a]
++
           String
"Accepts unix-timestamps (e.g. '@1474732068'), ISO8601 UTC timestamps " forall a. [a] -> [a] -> [a]
++
           String
"(e.g. '2016-09-24T17:47:48Z'), or 'HEAD' (default: 'HEAD').")
          InstallFlags -> Flag TotalIndexState
installIndexState (\Flag TotalIndexState
v InstallFlags
flags -> InstallFlags
flags { installIndexState :: Flag TotalIndexState
installIndexState = Flag TotalIndexState
v })
          (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"STATE" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ String
"index-state must be a  " forall a. [a] -> [a] -> [a]
++
                                       String
"unix-timestamps (e.g. '@1474732068'), " forall a. [a] -> [a] -> [a]
++
                                       String
"a ISO8601 UTC timestamp " forall a. [a] -> [a] -> [a]
++
                                       String
"(e.g. '2016-09-24T17:47:48Z'), or 'HEAD'")
                                      (forall a. a -> Flag a
toFlag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                          (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> String
prettyShow))

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"root-cmd"]
          String
"(No longer supported, do not use.)"
          InstallFlags -> Flag String
installRootCmd (\Flag String
v InstallFlags
flags -> InstallFlags
flags { installRootCmd :: Flag String
installRootCmd = Flag String
v })
          (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"COMMAND" forall a. a -> Flag a
toFlag forall a. Flag a -> [a]
flagToList)

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"symlink-bindir"]
          String
"Add symlinks to installed executables into this directory."
           InstallFlags -> Flag String
installSymlinkBinDir (\Flag String
v InstallFlags
flags -> InstallFlags
flags { installSymlinkBinDir :: Flag String
installSymlinkBinDir = Flag String
v })
           (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"DIR")

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"build-summary"]
          String
"Save build summaries to file (name template can use $pkgid, $compiler, $os, $arch)"
          InstallFlags -> NubList PathTemplate
installSummaryFile (\NubList PathTemplate
v InstallFlags
flags -> InstallFlags
flags { installSummaryFile :: NubList PathTemplate
installSummaryFile = NubList PathTemplate
v })
          (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"TEMPLATE" (\String
x -> forall a. Ord a => [a] -> NubList a
toNubList [String -> PathTemplate
toPathTemplate String
x]) (forall a b. (a -> b) -> [a] -> [b]
map PathTemplate -> String
fromPathTemplate forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NubList a -> [a]
fromNubList))

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"build-log"]
          String
"Log all builds to file (name template can use $pkgid, $compiler, $os, $arch)"
          InstallFlags -> Flag PathTemplate
installLogFile (\Flag PathTemplate
v InstallFlags
flags -> InstallFlags
flags { installLogFile :: Flag PathTemplate
installLogFile = Flag PathTemplate
v })
          (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"TEMPLATE" (forall a. a -> Flag a
toFlagforall b c a. (b -> c) -> (a -> b) -> a -> c
.String -> PathTemplate
toPathTemplate)
                              (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap PathTemplate -> String
fromPathTemplate))

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"remote-build-reporting"]
          String
"Generate build reports to send to a remote server (none, anonymous or detailed)."
          InstallFlags -> Flag ReportLevel
installBuildReports (\Flag ReportLevel
v InstallFlags
flags -> InstallFlags
flags { installBuildReports :: Flag ReportLevel
installBuildReports = Flag ReportLevel
v })
          (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"LEVEL" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ String
"report level must be 'none', "
                                            forall a. [a] -> [a] -> [a]
++ String
"'anonymous' or 'detailed'")
                                      (forall a. a -> Flag a
toFlag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                          (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> String
prettyShow))

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"report-planning-failure"]
          String
"Generate build reports when the dependency solver fails. This is used by the Hackage build bot."
          InstallFlags -> Flag Bool
installReportPlanningFailure (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installReportPlanningFailure :: Flag Bool
installReportPlanningFailure = Flag Bool
v })
          forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"" [String
"per-component"]
          String
"Per-component builds when possible"
          InstallFlags -> Flag Bool
installPerComponent (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installPerComponent :: Flag Bool
installPerComponent = Flag Bool
v })
          (forall a.
String
-> String -> MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
boolOpt [] [])

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"run-tests"]
          String
"Run package test suites during installation."
          InstallFlags -> Flag Bool
installRunTests (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installRunTests :: Flag Bool
installRunTests = Flag Bool
v })
          forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

      , forall flags.
(flags -> Flag (Maybe Int))
-> (Flag (Maybe Int) -> flags -> flags) -> OptionField flags
optionNumJobs
        InstallFlags -> Flag (Maybe Int)
installNumJobs (\Flag (Maybe Int)
v InstallFlags
flags -> InstallFlags
flags { installNumJobs :: Flag (Maybe Int)
installNumJobs = Flag (Maybe Int)
v })

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"keep-going"]
          String
"After a build failure, continue to build other unaffected packages."
          InstallFlags -> Flag Bool
installKeepGoing (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installKeepGoing :: Flag Bool
installKeepGoing = Flag Bool
v })
          forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"offline"]
          String
"Don't download packages from the Internet."
          InstallFlags -> Flag Bool
installOfflineMode (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installOfflineMode :: Flag Bool
installOfflineMode = Flag Bool
v })
          (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)

      ] forall a. [a] -> [a] -> [a]
++ case ShowOrParseArgs
showOrParseArgs of      -- TODO: remove when "cabal install"
                                        -- avoids
          ShowOrParseArgs
ParseArgs ->
            [ forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"only"]
              String
"Only installs the package in the current directory."
              InstallFlags -> Flag Bool
installOnly (\Flag Bool
v InstallFlags
flags -> InstallFlags
flags { installOnly :: Flag Bool
installOnly = Flag Bool
v })
              forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg ]
          ShowOrParseArgs
_ -> []


instance Monoid InstallFlags where
  mempty :: InstallFlags
mempty = forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: InstallFlags -> InstallFlags -> InstallFlags
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup InstallFlags where
  <> :: InstallFlags -> InstallFlags -> InstallFlags
(<>) = forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend

-- ------------------------------------------------------------
-- * Upload flags
-- ------------------------------------------------------------

-- | Is this a candidate package or a package to be published?
data IsCandidate = IsCandidate | IsPublished
                 deriving IsCandidate -> IsCandidate -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IsCandidate -> IsCandidate -> Bool
$c/= :: IsCandidate -> IsCandidate -> Bool
== :: IsCandidate -> IsCandidate -> Bool
$c== :: IsCandidate -> IsCandidate -> Bool
Eq

data UploadFlags = UploadFlags {
    UploadFlags -> Flag IsCandidate
uploadCandidate   :: Flag IsCandidate,
    UploadFlags -> Flag Bool
uploadDoc         :: Flag Bool,
    UploadFlags -> Flag Username
uploadUsername    :: Flag Username,
    UploadFlags -> Flag Password
uploadPassword    :: Flag Password,
    UploadFlags -> Flag [String]
uploadPasswordCmd :: Flag [String],
    UploadFlags -> Flag Verbosity
uploadVerbosity   :: Flag Verbosity
  } deriving forall x. Rep UploadFlags x -> UploadFlags
forall x. UploadFlags -> Rep UploadFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UploadFlags x -> UploadFlags
$cfrom :: forall x. UploadFlags -> Rep UploadFlags x
Generic

defaultUploadFlags :: UploadFlags
defaultUploadFlags :: UploadFlags
defaultUploadFlags = UploadFlags {
    uploadCandidate :: Flag IsCandidate
uploadCandidate   = forall a. a -> Flag a
toFlag IsCandidate
IsCandidate,
    uploadDoc :: Flag Bool
uploadDoc         = forall a. a -> Flag a
toFlag Bool
False,
    uploadUsername :: Flag Username
uploadUsername    = forall a. Monoid a => a
mempty,
    uploadPassword :: Flag Password
uploadPassword    = forall a. Monoid a => a
mempty,
    uploadPasswordCmd :: Flag [String]
uploadPasswordCmd = forall a. Monoid a => a
mempty,
    uploadVerbosity :: Flag Verbosity
uploadVerbosity   = forall a. a -> Flag a
toFlag Verbosity
normal
  }

uploadCommand :: CommandUI UploadFlags
uploadCommand :: CommandUI UploadFlags
uploadCommand =
  CommandUI
    { commandName :: String
commandName = String
"upload"
    , commandSynopsis :: String
commandSynopsis = String
"Uploads source packages or documentation to Hackage."
    , commandDescription :: Maybe (String -> String)
commandDescription = forall a. Maybe a
Nothing
    , commandNotes :: Maybe (String -> String)
commandNotes = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ ->
        String
"You can store your Hackage login in the ~/.config/cabal/config file\n"
          forall a. [a] -> [a] -> [a]
++ [String] -> String
relevantConfigValuesText [String
"username", String
"password", String
"password-command"]
    , commandUsage :: String -> String
commandUsage = \String
pname ->
        String
"Usage: " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" upload [FLAGS] TARFILES\n"
    , commandDefaultFlags :: UploadFlags
commandDefaultFlags = UploadFlags
defaultUploadFlags
    , commandOptions :: ShowOrParseArgs -> [OptionField UploadFlags]
commandOptions = \ShowOrParseArgs
_ ->
        [ forall flags.
(flags -> Flag Verbosity)
-> (Flag Verbosity -> flags -> flags) -> OptionField flags
optionVerbosity
            UploadFlags -> Flag Verbosity
uploadVerbosity
            (\Flag Verbosity
v UploadFlags
flags -> UploadFlags
flags{uploadVerbosity :: Flag Verbosity
uploadVerbosity = Flag Verbosity
v})
        , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option
            []
            [String
"publish"]
            String
"Publish the package instead of uploading it as a candidate."
            UploadFlags -> Flag IsCandidate
uploadCandidate
            (\Flag IsCandidate
v UploadFlags
flags -> UploadFlags
flags{uploadCandidate :: Flag IsCandidate
uploadCandidate = Flag IsCandidate
v})
            (forall b a. Eq b => b -> MkOptDescr (a -> b) (b -> a -> a) a
noArg (forall a. a -> Flag a
Flag IsCandidate
IsPublished))
        , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option
            [Char
'd']
            [String
"documentation"]
            ( String
"Upload documentation instead of a source package. "
                forall a. [a] -> [a] -> [a]
++ String
"By default, this uploads documentation for a package candidate. "
                forall a. [a] -> [a] -> [a]
++ String
"To upload documentation for "
                forall a. [a] -> [a] -> [a]
++ String
"a published package, combine with --publish."
            )
            UploadFlags -> Flag Bool
uploadDoc
            (\Flag Bool
v UploadFlags
flags -> UploadFlags
flags{uploadDoc :: Flag Bool
uploadDoc = Flag Bool
v})
            forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg
        , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option
            [Char
'u']
            [String
"username"]
            String
"Hackage username."
            UploadFlags -> Flag Username
uploadUsername
            (\Flag Username
v UploadFlags
flags -> UploadFlags
flags{uploadUsername :: Flag Username
uploadUsername = Flag Username
v})
            ( forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg'
                String
"USERNAME"
                (forall a. a -> Flag a
toFlag forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Username
Username)
                (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Username -> String
unUsername)
            )
        , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option
            [Char
'p']
            [String
"password"]
            String
"Hackage password."
            UploadFlags -> Flag Password
uploadPassword
            (\Flag Password
v UploadFlags
flags -> UploadFlags
flags{uploadPassword :: Flag Password
uploadPassword = Flag Password
v})
            ( forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg'
                String
"PASSWORD"
                (forall a. a -> Flag a
toFlag forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Password
Password)
                (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Password -> String
unPassword)
            )
        , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option
            [Char
'P']
            [String
"password-command"]
            String
"Command to get Hackage password."
            UploadFlags -> Flag [String]
uploadPasswordCmd
            (\Flag [String]
v UploadFlags
flags -> UploadFlags
flags{uploadPasswordCmd :: Flag [String]
uploadPasswordCmd = Flag [String]
v})
            ( forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg
                String
"COMMAND"
                ( forall a. (String -> String) -> ReadP a a -> ReadE a
readP_to_E
                    (String
"Cannot parse command: " forall a. [a] -> [a] -> [a]
++)
                    (forall a. a -> Flag a
Flag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall r a. ReadP r a -> ReadP r [a]
parseSpaceList forall r. ReadP r String
parseTokenQ)
                )
                (forall b a. b -> (a -> b) -> Flag a -> b
flagElim [] (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> String
unwords forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Show a => a -> String
show))
            )
        ]
    }

instance Monoid UploadFlags where
  mempty :: UploadFlags
mempty = forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: UploadFlags -> UploadFlags -> UploadFlags
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup UploadFlags where
  <> :: UploadFlags -> UploadFlags -> UploadFlags
(<>) = forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend

-- ------------------------------------------------------------
-- * Init flags
-- ------------------------------------------------------------

initCommand :: CommandUI IT.InitFlags
initCommand :: CommandUI InitFlags
initCommand = CommandUI {
    commandName :: String
commandName = String
"init",
    commandSynopsis :: String
commandSynopsis = String
"Create a new cabal package.",
    commandDescription :: Maybe (String -> String)
commandDescription = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
         String
"Create a .cabal, CHANGELOG.md, minimal initial Haskell code and optionally a LICENSE file.\n"
      forall a. [a] -> [a] -> [a]
++ String
"\n"
      forall a. [a] -> [a] -> [a]
++ String
"Calling init with no arguments runs interactive mode, "
      forall a. [a] -> [a] -> [a]
++ String
"which will try to guess as much as possible and prompt you for the rest.\n"
      forall a. [a] -> [a] -> [a]
++ String
"Non-interactive mode can be invoked by the -n/--non-interactive flag, "
      forall a. [a] -> [a] -> [a]
++ String
"which will let you specify the options via flags and will use the defaults for the rest.\n"
      forall a. [a] -> [a] -> [a]
++ String
"It is also possible to call init with a single argument, which denotes the project's desired "
      forall a. [a] -> [a] -> [a]
++ String
"root directory.\n",
    commandNotes :: Maybe (String -> String)
commandNotes = forall a. Maybe a
Nothing,
    commandUsage :: String -> String
commandUsage = \String
pname ->
         String
"Usage: " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" init [PROJECT ROOT] [FLAGS]\n",
    commandDefaultFlags :: InitFlags
commandDefaultFlags = InitFlags
IT.defaultInitFlags,
    commandOptions :: ShowOrParseArgs -> [OptionField InitFlags]
commandOptions = ShowOrParseArgs -> [OptionField InitFlags]
initOptions
  }

initOptions :: ShowOrParseArgs -> [OptionField IT.InitFlags]
initOptions :: ShowOrParseArgs -> [OptionField InitFlags]
initOptions ShowOrParseArgs
_ =
  [ forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'i'] [String
"interactive"]
    String
"interactive mode."
    InitFlags -> Flag Bool
IT.interactive (\Flag Bool
v InitFlags
flags -> InitFlags
flags { interactive :: Flag Bool
IT.interactive = Flag Bool
v })
    (forall a.
OptFlags
-> OptFlags -> MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
boolOpt' ([Char
'i'], [String
"interactive"]) ([Char
'n'], [String
"non-interactive"]))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'q'] [String
"quiet"]
    String
"Do not generate log messages to stdout."
    InitFlags -> Flag Bool
IT.quiet (\Flag Bool
v InitFlags
flags -> InitFlags
flags { quiet :: Flag Bool
IT.quiet = Flag Bool
v })
    forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"no-comments"]
    String
"Do not generate explanatory comments in the .cabal file."
    InitFlags -> Flag Bool
IT.noComments (\Flag Bool
v InitFlags
flags -> InitFlags
flags { noComments :: Flag Bool
IT.noComments = Flag Bool
v })
    forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'm'] [String
"minimal"]
    String
"Generate a minimal .cabal file, that is, do not include extra empty fields.  Also implies --no-comments."
    InitFlags -> Flag Bool
IT.minimal (\Flag Bool
v InitFlags
flags -> InitFlags
flags { minimal :: Flag Bool
IT.minimal = Flag Bool
v })
    forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"overwrite"]
    String
"Overwrite any existing .cabal, LICENSE, or Setup.hs files without warning."
    InitFlags -> Flag Bool
IT.overwrite (\Flag Bool
v InitFlags
flags -> InitFlags
flags { overwrite :: Flag Bool
IT.overwrite = Flag Bool
v })
    forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"package-dir", String
"packagedir"]
    String
"Root directory of the package (default = current directory)."
    InitFlags -> Flag String
IT.packageDir (\Flag String
v InitFlags
flags -> InitFlags
flags { packageDir :: Flag String
IT.packageDir = Flag String
v })
    (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"DIRECTORY")

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'p'] [String
"package-name"]
    String
"Name of the Cabal package to create."
    InitFlags -> Flag PackageName
IT.packageName (\Flag PackageName
v InitFlags
flags -> InitFlags
flags { packageName :: Flag PackageName
IT.packageName = Flag PackageName
v })
    (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"PACKAGE" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (String
"Cannot parse package name: "forall a. [a] -> [a] -> [a]
++)
                                  (forall a. a -> Flag a
toFlag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                      (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> String
prettyShow))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"version"]
    String
"Initial version of the package."
    InitFlags -> Flag Version
IT.version (\Flag Version
v InitFlags
flags -> InitFlags
flags { version :: Flag Version
IT.version = Flag Version
v })
    (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"VERSION" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (String
"Cannot parse package version: "forall a. [a] -> [a] -> [a]
++)
                                  (forall a. a -> Flag a
toFlag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                      (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> String
prettyShow))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"cabal-version"]
    String
"Version of the Cabal specification."
    InitFlags -> Flag CabalSpecVersion
IT.cabalVersion (\Flag CabalSpecVersion
v InitFlags
flags -> InitFlags
flags { cabalVersion :: Flag CabalSpecVersion
IT.cabalVersion = Flag CabalSpecVersion
v })
    (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"CABALSPECVERSION" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (String
"Cannot parse Cabal specification version: "forall a. [a] -> [a] -> [a]
++)
                                        (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. a -> Flag a
toFlag forall b c a. (b -> c) -> (a -> b) -> a -> c
. SpecVersion -> CabalSpecVersion
getSpecVersion) forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                            (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. Pretty a => a -> String
prettyShow forall b c a. (b -> c) -> (a -> b) -> a -> c
. CabalSpecVersion -> SpecVersion
SpecVersion)))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'l'] [String
"license"]
    String
"Project license."
    InitFlags -> Flag SpecLicense
IT.license (\Flag SpecLicense
v InitFlags
flags -> InitFlags
flags { license :: Flag SpecLicense
IT.license = Flag SpecLicense
v })
    (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"LICENSE" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (String
"Cannot parse license: "forall a. [a] -> [a] -> [a]
++)
                                  (forall a. a -> Flag a
toFlag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                      (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> String
prettyShow))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'a'] [String
"author"]
    String
"Name of the project's author."
    InitFlags -> Flag String
IT.author (\Flag String
v InitFlags
flags -> InitFlags
flags { author :: Flag String
IT.author = Flag String
v })
    (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"NAME")

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'e'] [String
"email"]
    String
"Email address of the maintainer."
    InitFlags -> Flag String
IT.email (\Flag String
v InitFlags
flags -> InitFlags
flags { email :: Flag String
IT.email = Flag String
v })
    (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"EMAIL")

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'u'] [String
"homepage"]
    String
"Project homepage and/or repository."
    InitFlags -> Flag String
IT.homepage (\Flag String
v InitFlags
flags -> InitFlags
flags { homepage :: Flag String
IT.homepage = Flag String
v })
    (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"URL")

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
's'] [String
"synopsis"]
    String
"Short project synopsis."
    InitFlags -> Flag String
IT.synopsis (\Flag String
v InitFlags
flags -> InitFlags
flags { synopsis :: Flag String
IT.synopsis = Flag String
v })
    (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"TEXT")

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'c'] [String
"category"]
    String
"Project category."
    InitFlags -> Flag String
IT.category (\Flag String
v InitFlags
flags -> InitFlags
flags { category :: Flag String
IT.category = Flag String
v })
    (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"CATEGORY")

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'x'] [String
"extra-source-file"]
    String
"Extra source file to be distributed with tarball."
    InitFlags -> Flag [String]
IT.extraSrc
    (\Flag [String]
v InitFlags
flags -> InitFlags
flags { extraSrc :: Flag [String]
IT.extraSrc = forall a. Flag [a] -> Flag [a] -> Flag [a]
mergeListFlag (InitFlags -> Flag [String]
IT.extraSrc InitFlags
flags) Flag [String]
v })
    (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"FILE" (forall a. a -> Flag a
Flag forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[]))
                    (forall a. a -> Flag a -> a
fromFlagOrDefault []))
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"extra-doc-file"]
    String
"Extra doc file to be distributed with tarball."
    InitFlags -> Flag [String]
IT.extraDoc
    (\Flag [String]
v InitFlags
flags -> InitFlags
flags { extraDoc :: Flag [String]
IT.extraDoc = forall a. Flag [a] -> Flag [a] -> Flag [a]
mergeListFlag (InitFlags -> Flag [String]
IT.extraDoc InitFlags
flags) Flag [String]
v })
    (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"FILE" (forall a. a -> Flag a
Flag forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[])) (forall a. a -> Flag a -> a
fromFlagOrDefault []))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"lib", String
"is-library"]
    String
"Build a library."
    InitFlags -> Flag PackageType
IT.packageType (\Flag PackageType
v InitFlags
flags -> InitFlags
flags { packageType :: Flag PackageType
IT.packageType = Flag PackageType
v })
    (forall b a. Eq b => b -> MkOptDescr (a -> b) (b -> a -> a) a
noArg (forall a. a -> Flag a
Flag PackageType
IT.Library))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"exe", String
"is-executable"]
    String
"Build an executable."
    InitFlags -> Flag PackageType
IT.packageType
    (\Flag PackageType
v InitFlags
flags -> InitFlags
flags { packageType :: Flag PackageType
IT.packageType = Flag PackageType
v })
    (forall b a. Eq b => b -> MkOptDescr (a -> b) (b -> a -> a) a
noArg (forall a. a -> Flag a
Flag PackageType
IT.Executable))

    , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"libandexe", String
"is-libandexe"]
    String
"Build a library and an executable."
    InitFlags -> Flag PackageType
IT.packageType
    (\Flag PackageType
v InitFlags
flags -> InitFlags
flags { packageType :: Flag PackageType
IT.packageType = Flag PackageType
v })
    (forall b a. Eq b => b -> MkOptDescr (a -> b) (b -> a -> a) a
noArg (forall a. a -> Flag a
Flag PackageType
IT.LibraryAndExecutable))

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"tests"]
        String
"Generate a test suite, standalone or for a library."
        InitFlags -> Flag Bool
IT.initializeTestSuite
        (\Flag Bool
v InitFlags
flags -> InitFlags
flags { initializeTestSuite :: Flag Bool
IT.initializeTestSuite = Flag Bool
v })
        forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

      , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"test-dir"]
        String
"Directory containing tests."
        InitFlags -> Flag [String]
IT.testDirs (\Flag [String]
v InitFlags
flags ->
          InitFlags
flags { testDirs :: Flag [String]
IT.testDirs = forall a. Flag [a] -> Flag [a] -> Flag [a]
mergeListFlag (InitFlags -> Flag [String]
IT.testDirs InitFlags
flags) Flag [String]
v })
        (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"DIR" (forall a. a -> Flag a
Flag forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[]))
                       (forall a. a -> Flag a -> a
fromFlagOrDefault []))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"simple"]
    String
"Create a simple project with sensible defaults."
    InitFlags -> Flag Bool
IT.simpleProject
    (\Flag Bool
v InitFlags
flags -> InitFlags
flags { simpleProject :: Flag Bool
IT.simpleProject = Flag Bool
v })
    forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"main-is"]
    String
"Specify the main module."
    InitFlags -> Flag String
IT.mainIs
    (\Flag String
v InitFlags
flags -> InitFlags
flags { mainIs :: Flag String
IT.mainIs = Flag String
v })
    (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"FILE")

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"language"]
    String
"Specify the default language."
    InitFlags -> Flag Language
IT.language
    (\Flag Language
v InitFlags
flags -> InitFlags
flags { language :: Flag Language
IT.language = Flag Language
v })
    (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"LANGUAGE" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (String
"Cannot parse language: "forall a. [a] -> [a] -> [a]
++)
                                   (forall a. a -> Flag a
toFlag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                      (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> String
prettyShow))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'o'] [String
"expose-module"]
    String
"Export a module from the package."
    InitFlags -> Flag [ModuleName]
IT.exposedModules
    (\Flag [ModuleName]
v InitFlags
flags -> InitFlags
flags { exposedModules :: Flag [ModuleName]
IT.exposedModules =
      forall a. Flag [a] -> Flag [a] -> Flag [a]
mergeListFlag (InitFlags -> Flag [ModuleName]
IT.exposedModules InitFlags
flags) Flag [ModuleName]
v})
    (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"MODULE" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (String
"Cannot parse module name: "forall a. [a] -> [a] -> [a]
++)
                                 (forall a. a -> Flag a
Flag forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                     (forall b a. b -> (a -> b) -> Flag a -> b
flagElim [] (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> String
prettyShow)))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"extension"]
    String
"Use a LANGUAGE extension (in the other-extensions field)."
    InitFlags -> Flag [Extension]
IT.otherExts
    (\Flag [Extension]
v InitFlags
flags -> InitFlags
flags { otherExts :: Flag [Extension]
IT.otherExts =
      forall a. Flag [a] -> Flag [a] -> Flag [a]
mergeListFlag (InitFlags -> Flag [Extension]
IT.otherExts InitFlags
flags) Flag [Extension]
v })
    (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"EXTENSION" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (String
"Cannot parse extension: "forall a. [a] -> [a] -> [a]
++)
                                    (forall a. a -> Flag a
Flag forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[]) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                        (forall b a. b -> (a -> b) -> Flag a -> b
flagElim [] (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> String
prettyShow)))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'd'] [String
"dependency"]
    String
"Package dependencies. Permits comma separated list of dependencies."
    InitFlags -> Flag [Dependency]
IT.dependencies
    (\Flag [Dependency]
v InitFlags
flags -> InitFlags
flags { dependencies :: Flag [Dependency]
IT.dependencies =
      forall a. Flag [a] -> Flag [a] -> Flag [a]
mergeListFlag (InitFlags -> Flag [Dependency]
IT.dependencies InitFlags
flags) Flag [Dependency]
v })
    (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"DEPENDENCIES" (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Flag a
Flag ReadE [Dependency]
dependenciesReadE)
                           (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> String
prettyShow forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Flag a -> a
fromFlagOrDefault []))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"application-dir"]
    String
"Directory containing package application executable."
    InitFlags -> Flag [String]
IT.applicationDirs (\Flag [String]
v InitFlags
flags -> InitFlags
flags { applicationDirs :: Flag [String]
IT.applicationDirs =
      forall a. Flag [a] -> Flag [a] -> Flag [a]
mergeListFlag (InitFlags -> Flag [String]
IT.applicationDirs InitFlags
flags) Flag [String]
v})
    (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"DIR" (forall a. a -> Flag a
Flag forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[]))
                   (forall a. a -> Flag a -> a
fromFlagOrDefault []))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"source-dir", String
"sourcedir"]
    String
"Directory containing package library source."
    InitFlags -> Flag [String]
IT.sourceDirs (\Flag [String]
v InitFlags
flags -> InitFlags
flags { sourceDirs :: Flag [String]
IT.sourceDirs =
      forall a. Flag [a] -> Flag [a] -> Flag [a]
mergeListFlag (InitFlags -> Flag [String]
IT.sourceDirs InitFlags
flags) Flag [String]
v })
    (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"DIR" (forall a. a -> Flag a
Flagforall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[]))
                   (forall a. a -> Flag a -> a
fromFlagOrDefault []))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"build-tool"]
    String
"Required external build tool."
    InitFlags -> Flag [String]
IT.buildTools (\Flag [String]
v InitFlags
flags -> InitFlags
flags { buildTools :: Flag [String]
IT.buildTools =
      forall a. Flag [a] -> Flag [a] -> Flag [a]
mergeListFlag (InitFlags -> Flag [String]
IT.buildTools InitFlags
flags) Flag [String]
v })
    (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"TOOL" (forall a. a -> Flag a
Flag forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[]))
                    (forall a. a -> Flag a -> a
fromFlagOrDefault []))

  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"w" [String
"with-compiler"]
    String
"give the path to a particular compiler. For 'init', this flag is used \
    \to set the bounds inferred for the 'base' package."
    InitFlags -> Flag String
IT.initHcPath (\Flag String
v InitFlags
flags -> InitFlags
flags { initHcPath :: Flag String
IT.initHcPath = Flag String
v })
    (forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
"PATH")

  , forall flags.
(flags -> Flag Verbosity)
-> (Flag Verbosity -> flags -> flags) -> OptionField flags
optionVerbosity InitFlags -> Flag Verbosity
IT.initVerbosity (\Flag Verbosity
v InitFlags
flags -> InitFlags
flags { initVerbosity :: Flag Verbosity
IT.initVerbosity = Flag Verbosity
v })
  ]
  where
    dependenciesReadE :: ReadE [Dependency]
    dependenciesReadE :: ReadE [Dependency]
dependenciesReadE =
      forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE
        (String
"Cannot parse dependencies: " forall a. [a] -> [a] -> [a]
++)
        (forall (m :: * -> *) a. CabalParsing m => m a -> m [a]
parsecCommaList forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec)

    mergeListFlag :: Flag [a] -> Flag [a] -> Flag [a]
    mergeListFlag :: forall a. Flag [a] -> Flag [a] -> Flag [a]
mergeListFlag Flag [a]
currentFlags Flag [a]
v =
      forall a. a -> Flag a
Flag forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (forall a. Flag a -> [a]
flagToList Flag [a]
currentFlags forall a. [a] -> [a] -> [a]
++ forall a. Flag a -> [a]
flagToList Flag [a]
v)

-- ------------------------------------------------------------
-- * Copy and Register
-- ------------------------------------------------------------

copyCommand :: CommandUI CopyFlags
copyCommand :: CommandUI CopyFlags
copyCommand = CommandUI CopyFlags
Cabal.copyCommand
 { commandNotes :: Maybe (String -> String)
commandNotes = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
pname ->
    String
"Examples:\n"
     forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-copy           "
     forall a. [a] -> [a] -> [a]
++ String
"    All the components in the package\n"
     forall a. [a] -> [a] -> [a]
++ String
"  " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-copy foo       "
     forall a. [a] -> [a] -> [a]
++ String
"    A component (i.e. lib, exe, test suite)"
  , commandUsage :: String -> String
commandUsage = String -> [String] -> String -> String
usageAlternatives String
"v1-copy" forall a b. (a -> b) -> a -> b
$
    [ String
"[FLAGS]"
    , String
"COMPONENTS [FLAGS]"
    ]
 }

registerCommand :: CommandUI RegisterFlags
registerCommand :: CommandUI RegisterFlags
registerCommand = CommandUI RegisterFlags
Cabal.registerCommand
 { commandUsage :: String -> String
commandUsage = \String
pname ->  String
"Usage: " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" v1-register [FLAGS]\n" }

-- ------------------------------------------------------------
-- * ActAsSetup flags
-- ------------------------------------------------------------

data ActAsSetupFlags = ActAsSetupFlags {
    ActAsSetupFlags -> Flag BuildType
actAsSetupBuildType :: Flag BuildType
} deriving forall x. Rep ActAsSetupFlags x -> ActAsSetupFlags
forall x. ActAsSetupFlags -> Rep ActAsSetupFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ActAsSetupFlags x -> ActAsSetupFlags
$cfrom :: forall x. ActAsSetupFlags -> Rep ActAsSetupFlags x
Generic

defaultActAsSetupFlags :: ActAsSetupFlags
defaultActAsSetupFlags :: ActAsSetupFlags
defaultActAsSetupFlags = ActAsSetupFlags {
    actAsSetupBuildType :: Flag BuildType
actAsSetupBuildType = forall a. a -> Flag a
toFlag BuildType
Simple
}

actAsSetupCommand :: CommandUI ActAsSetupFlags
actAsSetupCommand :: CommandUI ActAsSetupFlags
actAsSetupCommand = CommandUI {
  commandName :: String
commandName         = String
"act-as-setup",
  commandSynopsis :: String
commandSynopsis     = String
"Run as-if this was a Setup.hs",
  commandDescription :: Maybe (String -> String)
commandDescription  = forall a. Maybe a
Nothing,
  commandNotes :: Maybe (String -> String)
commandNotes        = forall a. Maybe a
Nothing,
  commandUsage :: String -> String
commandUsage        = \String
pname ->
    String
"Usage: " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" act-as-setup\n",
  commandDefaultFlags :: ActAsSetupFlags
commandDefaultFlags = ActAsSetupFlags
defaultActAsSetupFlags,
  commandOptions :: ShowOrParseArgs -> [OptionField ActAsSetupFlags]
commandOptions      = \ShowOrParseArgs
_ ->
      [forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option String
"" [String
"build-type"]
         String
"Use the given build type."
         ActAsSetupFlags -> Flag BuildType
actAsSetupBuildType (\Flag BuildType
v ActAsSetupFlags
flags -> ActAsSetupFlags
flags { actAsSetupBuildType :: Flag BuildType
actAsSetupBuildType = Flag BuildType
v })
         (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"BUILD-TYPE" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (String
"Cannot parse build type: "forall a. [a] -> [a] -> [a]
++)
                               (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Flag a
toFlag forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                              (forall a b. (a -> b) -> [a] -> [b]
map forall a. Pretty a => a -> String
prettyShow forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Flag a -> [a]
flagToList))
      ]
}

instance Monoid ActAsSetupFlags where
  mempty :: ActAsSetupFlags
mempty = forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: ActAsSetupFlags -> ActAsSetupFlags -> ActAsSetupFlags
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup ActAsSetupFlags where
  <> :: ActAsSetupFlags -> ActAsSetupFlags -> ActAsSetupFlags
(<>) = forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend

-- ------------------------------------------------------------
-- * UserConfig flags
-- ------------------------------------------------------------

data UserConfigFlags = UserConfigFlags {
  UserConfigFlags -> Flag Verbosity
userConfigVerbosity   :: Flag Verbosity,
  UserConfigFlags -> Flag Bool
userConfigForce       :: Flag Bool,
  UserConfigFlags -> Flag [String]
userConfigAppendLines :: Flag [String]
  } deriving forall x. Rep UserConfigFlags x -> UserConfigFlags
forall x. UserConfigFlags -> Rep UserConfigFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UserConfigFlags x -> UserConfigFlags
$cfrom :: forall x. UserConfigFlags -> Rep UserConfigFlags x
Generic

instance Monoid UserConfigFlags where
  mempty :: UserConfigFlags
mempty = UserConfigFlags {
    userConfigVerbosity :: Flag Verbosity
userConfigVerbosity   = forall a. a -> Flag a
toFlag Verbosity
normal,
    userConfigForce :: Flag Bool
userConfigForce       = forall a. a -> Flag a
toFlag Bool
False,
    userConfigAppendLines :: Flag [String]
userConfigAppendLines = forall a. a -> Flag a
toFlag []
    }
  mappend :: UserConfigFlags -> UserConfigFlags -> UserConfigFlags
mappend = forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup UserConfigFlags where
  <> :: UserConfigFlags -> UserConfigFlags -> UserConfigFlags
(<>) = forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend

userConfigCommand :: CommandUI UserConfigFlags
userConfigCommand :: CommandUI UserConfigFlags
userConfigCommand = CommandUI {
  commandName :: String
commandName         = String
"user-config",
  commandSynopsis :: String
commandSynopsis     = String
"Display and update the user's global cabal configuration.",
  commandDescription :: Maybe (String -> String)
commandDescription  = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ \String
_ -> String -> String
wrapText forall a b. (a -> b) -> a -> b
$
       String
"When upgrading cabal, the set of configuration keys and their default"
    forall a. [a] -> [a] -> [a]
++ String
" values may change. This command provides means to merge the existing"
    forall a. [a] -> [a] -> [a]
++ String
" config in ~/.config/cabal/config"
    forall a. [a] -> [a] -> [a]
++ String
" (i.e. all bindings that are actually defined and not commented out)"
    forall a. [a] -> [a] -> [a]
++ String
" and the default config of the new version.\n"
    forall a. [a] -> [a] -> [a]
++ String
"\n"
    forall a. [a] -> [a] -> [a]
++ String
"init: Creates a new config file at either ~/.config/cabal/config or as"
    forall a. [a] -> [a] -> [a]
++ String
" specified by --config-file, if given. An existing file won't be "
    forall a. [a] -> [a] -> [a]
++ String
" overwritten unless -f or --force is given.\n"
    forall a. [a] -> [a] -> [a]
++ String
"diff: Shows a pseudo-diff of the user's ~/.config/cabal/config file and"
    forall a. [a] -> [a] -> [a]
++ String
" the default configuration that would be created by cabal if the"
    forall a. [a] -> [a] -> [a]
++ String
" config file did not exist.\n"
    forall a. [a] -> [a] -> [a]
++ String
"update: Applies the pseudo-diff to the configuration that would be"
    forall a. [a] -> [a] -> [a]
++ String
" created by default, and write the result back to ~/.config/cabal/config.",

  commandNotes :: Maybe (String -> String)
commandNotes        = forall a. Maybe a
Nothing,
  commandUsage :: String -> String
commandUsage        = String -> [String] -> String -> String
usageAlternatives String
"user-config" [String
"init", String
"diff", String
"update"],
  commandDefaultFlags :: UserConfigFlags
commandDefaultFlags = forall a. Monoid a => a
mempty,
  commandOptions :: ShowOrParseArgs -> [OptionField UserConfigFlags]
commandOptions      = \ ShowOrParseArgs
_ -> [
   forall flags.
(flags -> Flag Verbosity)
-> (Flag Verbosity -> flags -> flags) -> OptionField flags
optionVerbosity UserConfigFlags -> Flag Verbosity
userConfigVerbosity (\Flag Verbosity
v UserConfigFlags
flags -> UserConfigFlags
flags { userConfigVerbosity :: Flag Verbosity
userConfigVerbosity = Flag Verbosity
v })
 , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'f'] [String
"force"]
     String
"Overwrite the config file if it already exists."
     UserConfigFlags -> Flag Bool
userConfigForce (\Flag Bool
v UserConfigFlags
flags -> UserConfigFlags
flags { userConfigForce :: Flag Bool
userConfigForce = Flag Bool
v })
     forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg
 , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [Char
'a'] [String
"augment"]
     String
"Additional setting to augment the config file (replacing a previous setting if it existed)."
     UserConfigFlags -> Flag [String]
userConfigAppendLines (\Flag [String]
v UserConfigFlags
flags -> UserConfigFlags
flags
                               {userConfigAppendLines :: Flag [String]
userConfigAppendLines =
                                   forall a. a -> Flag a
Flag forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (forall a. Flag a -> [a]
flagToList (UserConfigFlags -> Flag [String]
userConfigAppendLines UserConfigFlags
flags) forall a. [a] -> [a] -> [a]
++ forall a. Flag a -> [a]
flagToList Flag [String]
v)})
     (forall b a.
Monoid b =>
String
-> (String -> b)
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg' String
"CONFIGLINE" (forall a. a -> Flag a
Flag forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. a -> [a] -> [a]
:[])) (forall a. a -> Maybe a -> a
fromMaybe [] forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Flag a -> Maybe a
flagToMaybe))
   ]
  }


-- ------------------------------------------------------------
-- * GetOpt Utils
-- ------------------------------------------------------------

reqArgFlag :: ArgPlaceHolder ->
              MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag :: forall b.
String -> MkOptDescr (b -> Flag String) (Flag String -> b -> b) b
reqArgFlag String
ad = forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
ad (forall a. (String -> a) -> ReadE a
succeedReadE forall a. a -> Flag a
Flag) forall a. Flag a -> [a]
flagToList

liftOptions :: (b -> a) -> (a -> b -> b)
            -> [OptionField a] -> [OptionField b]
liftOptions :: forall b a.
(b -> a) -> (a -> b -> b) -> [OptionField a] -> [OptionField b]
liftOptions b -> a
get a -> b -> b
set = forall a b. (a -> b) -> [a] -> [b]
map (forall b a.
(b -> a) -> (a -> b -> b) -> OptionField a -> OptionField b
liftOption b -> a
get a -> b -> b
set)

yesNoOpt :: ShowOrParseArgs -> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt :: forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
ShowArgs String
sf [String]
lf = forall a. MkOptDescr (a -> Flag Bool) (Flag Bool -> a -> a) a
trueArg String
sf [String]
lf
yesNoOpt ShowOrParseArgs
_        String
sf [String]
lf = forall b a.
(b -> Maybe Bool)
-> (Bool -> b)
-> OptFlags
-> OptFlags
-> MkOptDescr (a -> b) (b -> a -> a) a
Command.boolOpt' forall a. Flag a -> Maybe a
flagToMaybe forall a. a -> Flag a
Flag (String
sf, [String]
lf) ([], forall a b. (a -> b) -> [a] -> [b]
map (String
"no-" forall a. [a] -> [a] -> [a]
++) [String]
lf) String
sf [String]
lf

optionSolver :: (flags -> Flag PreSolver)
             -> (Flag PreSolver -> flags -> flags)
             -> OptionField flags
optionSolver :: forall flags.
(flags -> Flag PreSolver)
-> (Flag PreSolver -> flags -> flags) -> OptionField flags
optionSolver flags -> Flag PreSolver
get Flag PreSolver -> flags -> flags
set =
  forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"solver"]
    (String
"Select dependency solver to use (default: " forall a. [a] -> [a] -> [a]
++ forall a. Pretty a => a -> String
prettyShow PreSolver
defaultSolver forall a. [a] -> [a] -> [a]
++ String
"). Choices: " forall a. [a] -> [a] -> [a]
++ String
allSolvers forall a. [a] -> [a] -> [a]
++ String
".")
    flags -> Flag PreSolver
get Flag PreSolver -> flags -> flags
set
    (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"SOLVER" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ String
"solver must be one of: " forall a. [a] -> [a] -> [a]
++ String
allSolvers)
                                    (forall a. a -> Flag a
toFlag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
                     (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> String
prettyShow))

optionSolverFlags :: ShowOrParseArgs
                  -> (flags -> Flag Int   ) -> (Flag Int    -> flags -> flags)
                  -> (flags -> Flag ReorderGoals)     -> (Flag ReorderGoals     -> flags -> flags)
                  -> (flags -> Flag CountConflicts)   -> (Flag CountConflicts   -> flags -> flags)
                  -> (flags -> Flag FineGrainedConflicts) -> (Flag FineGrainedConflicts -> flags -> flags)
                  -> (flags -> Flag MinimizeConflictSet) -> (Flag MinimizeConflictSet -> flags -> flags)
                  -> (flags -> Flag IndependentGoals) -> (Flag IndependentGoals -> flags -> flags)
                  -> (flags -> Flag PreferOldest) -> (Flag PreferOldest -> flags -> flags)
                  -> (flags -> Flag ShadowPkgs)       -> (Flag ShadowPkgs       -> flags -> flags)
                  -> (flags -> Flag StrongFlags)      -> (Flag StrongFlags      -> flags -> flags)
                  -> (flags -> Flag AllowBootLibInstalls) -> (Flag AllowBootLibInstalls -> flags -> flags)
                  -> (flags -> Flag OnlyConstrained)  -> (Flag OnlyConstrained  -> flags -> flags)
                  -> [OptionField flags]
optionSolverFlags :: forall flags.
ShowOrParseArgs
-> (flags -> Flag Int)
-> (Flag Int -> flags -> flags)
-> (flags -> Flag ReorderGoals)
-> (Flag ReorderGoals -> flags -> flags)
-> (flags -> Flag CountConflicts)
-> (Flag CountConflicts -> flags -> flags)
-> (flags -> Flag FineGrainedConflicts)
-> (Flag FineGrainedConflicts -> flags -> flags)
-> (flags -> Flag MinimizeConflictSet)
-> (Flag MinimizeConflictSet -> flags -> flags)
-> (flags -> Flag IndependentGoals)
-> (Flag IndependentGoals -> flags -> flags)
-> (flags -> Flag PreferOldest)
-> (Flag PreferOldest -> flags -> flags)
-> (flags -> Flag ShadowPkgs)
-> (Flag ShadowPkgs -> flags -> flags)
-> (flags -> Flag StrongFlags)
-> (Flag StrongFlags -> flags -> flags)
-> (flags -> Flag AllowBootLibInstalls)
-> (Flag AllowBootLibInstalls -> flags -> flags)
-> (flags -> Flag OnlyConstrained)
-> (Flag OnlyConstrained -> flags -> flags)
-> [OptionField flags]
optionSolverFlags ShowOrParseArgs
showOrParseArgs flags -> Flag Int
getmbj Flag Int -> flags -> flags
setmbj flags -> Flag ReorderGoals
getrg Flag ReorderGoals -> flags -> flags
setrg flags -> Flag CountConflicts
getcc Flag CountConflicts -> flags -> flags
setcc
                  flags -> Flag FineGrainedConflicts
getfgc Flag FineGrainedConflicts -> flags -> flags
setfgc flags -> Flag MinimizeConflictSet
getmc Flag MinimizeConflictSet -> flags -> flags
setmc flags -> Flag IndependentGoals
getig Flag IndependentGoals -> flags -> flags
setig flags -> Flag PreferOldest
getpo Flag PreferOldest -> flags -> flags
setpo flags -> Flag ShadowPkgs
getsip Flag ShadowPkgs -> flags -> flags
setsip
                  flags -> Flag StrongFlags
getstrfl Flag StrongFlags -> flags -> flags
setstrfl flags -> Flag AllowBootLibInstalls
getib Flag AllowBootLibInstalls -> flags -> flags
setib flags -> Flag OnlyConstrained
getoc Flag OnlyConstrained -> flags -> flags
setoc =
  [ forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"max-backjumps"]
      (String
"Maximum number of backjumps allowed while solving (default: " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
defaultMaxBackjumps forall a. [a] -> [a] -> [a]
++ String
"). Use a negative number to enable unlimited backtracking. Use 0 to disable backtracking completely.")
      flags -> Flag Int
getmbj Flag Int -> flags -> flags
setmbj
      (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"NUM" (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE (String
"Cannot parse number: "forall a. [a] -> [a] -> [a]
++) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Flag a
toFlag forall (m :: * -> *) a. (CharParsing m, Integral a) => m a
P.signedIntegral))
                    (forall a b. (a -> b) -> [a] -> [b]
map forall a. Show a => a -> String
show forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Flag a -> [a]
flagToList))
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"reorder-goals"]
      String
"Try to reorder goals according to certain heuristics. Slows things down on average, but may make backtracking faster for some packages."
      (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. BooleanFlag a => a -> Bool
asBool forall b c a. (b -> c) -> (a -> b) -> a -> c
. flags -> Flag ReorderGoals
getrg)
      (Flag ReorderGoals -> flags -> flags
setrg forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> ReorderGoals
ReorderGoals)
      (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"count-conflicts"]
      String
"Try to speed up solving by preferring goals that are involved in a lot of conflicts (default)."
      (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. BooleanFlag a => a -> Bool
asBool forall b c a. (b -> c) -> (a -> b) -> a -> c
. flags -> Flag CountConflicts
getcc)
      (Flag CountConflicts -> flags -> flags
setcc forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> CountConflicts
CountConflicts)
      (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"fine-grained-conflicts"]
      String
"Skip a version of a package if it does not resolve the conflicts encountered in the last version, as a solver optimization (default)."
      (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. BooleanFlag a => a -> Bool
asBool forall b c a. (b -> c) -> (a -> b) -> a -> c
. flags -> Flag FineGrainedConflicts
getfgc)
      (Flag FineGrainedConflicts -> flags -> flags
setfgc forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> FineGrainedConflicts
FineGrainedConflicts)
      (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"minimize-conflict-set"]
      (String
"When there is no solution, try to improve the error message by finding "
        forall a. [a] -> [a] -> [a]
++ String
"a minimal conflict set (default: false). May increase run time "
        forall a. [a] -> [a] -> [a]
++ String
"significantly.")
      (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. BooleanFlag a => a -> Bool
asBool forall b c a. (b -> c) -> (a -> b) -> a -> c
. flags -> Flag MinimizeConflictSet
getmc)
      (Flag MinimizeConflictSet -> flags -> flags
setmc forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> MinimizeConflictSet
MinimizeConflictSet)
      (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"independent-goals"]
      String
"Treat several goals on the command line as independent. If several goals depend on the same package, different versions can be chosen."
      (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. BooleanFlag a => a -> Bool
asBool forall b c a. (b -> c) -> (a -> b) -> a -> c
. flags -> Flag IndependentGoals
getig)
      (Flag IndependentGoals -> flags -> flags
setig forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> IndependentGoals
IndependentGoals)
      (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"prefer-oldest"]
      String
"Prefer the oldest (instead of the latest) versions of packages available. Useful to determine lower bounds in the build-depends section."
      (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. BooleanFlag a => a -> Bool
asBool forall b c a. (b -> c) -> (a -> b) -> a -> c
. flags -> Flag PreferOldest
getpo)
      (Flag PreferOldest -> flags -> flags
setpo forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> PreferOldest
PreferOldest)
      (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"shadow-installed-packages"]
      String
"If multiple package instances of the same version are installed, treat all but one as shadowed."
      (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. BooleanFlag a => a -> Bool
asBool forall b c a. (b -> c) -> (a -> b) -> a -> c
. flags -> Flag ShadowPkgs
getsip)
      (Flag ShadowPkgs -> flags -> flags
setsip forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> ShadowPkgs
ShadowPkgs)
      (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"strong-flags"]
      String
"Do not defer flag choices (this used to be the default in cabal-install <= 1.20)."
      (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. BooleanFlag a => a -> Bool
asBool forall b c a. (b -> c) -> (a -> b) -> a -> c
. flags -> Flag StrongFlags
getstrfl)
      (Flag StrongFlags -> flags -> flags
setstrfl forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> StrongFlags
StrongFlags)
      (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"allow-boot-library-installs"]
      String
"Allow cabal to install base, ghc-prim, integer-simple, integer-gmp, and template-haskell."
      (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. BooleanFlag a => a -> Bool
asBool forall b c a. (b -> c) -> (a -> b) -> a -> c
. flags -> Flag AllowBootLibInstalls
getib)
      (Flag AllowBootLibInstalls -> flags -> flags
setib forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> AllowBootLibInstalls
AllowBootLibInstalls)
      (forall b.
ShowOrParseArgs
-> MkOptDescr (b -> Flag Bool) (Flag Bool -> b -> b) b
yesNoOpt ShowOrParseArgs
showOrParseArgs)
  , forall get set a.
String
-> [String]
-> String
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option [] [String
"reject-unconstrained-dependencies"]
      String
"Require these packages to have constraints on them if they are to be selected (default: none)."
      flags -> Flag OnlyConstrained
getoc
      Flag OnlyConstrained -> flags -> flags
setoc
      (forall b a.
Monoid b =>
String
-> ReadE b
-> (b -> [String])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg String
"none|all"
         (forall a. (String -> String) -> ParsecParser a -> ReadE a
parsecToReadE
            (forall a b. a -> b -> a
const String
"reject-unconstrained-dependencies must be 'none' or 'all'")
            (forall a. a -> Flag a
toFlag forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec))
         (forall a. Flag a -> [a]
flagToList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. Pretty a => a -> String
prettyShow))

  ]

usagePackages :: String -> String -> String
usagePackages :: String -> String -> String
usagePackages String
name String
pname =
     String
"Usage: " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++ String
name forall a. [a] -> [a] -> [a]
++ String
" [PACKAGES]\n"

usageFlags :: String -> String -> String
usageFlags :: String -> String -> String
usageFlags String
name String
pname =
  String
"Usage: " forall a. [a] -> [a] -> [a]
++ String
pname forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++ String
name forall a. [a] -> [a] -> [a]
++ String
" [FLAGS]\n"

-- ------------------------------------------------------------
-- * Repo helpers
-- ------------------------------------------------------------

showRemoteRepo :: RemoteRepo -> String
showRemoteRepo :: RemoteRepo -> String
showRemoteRepo = forall a. Pretty a => a -> String
prettyShow

readRemoteRepo :: String -> Maybe RemoteRepo
readRemoteRepo :: String -> Maybe RemoteRepo
readRemoteRepo = forall a. Parsec a => String -> Maybe a
simpleParsec

showLocalRepo :: LocalRepo -> String
showLocalRepo :: LocalRepo -> String
showLocalRepo = forall a. Pretty a => a -> String
prettyShow

readLocalRepo :: String -> Maybe LocalRepo
readLocalRepo :: String -> Maybe LocalRepo
readLocalRepo = forall a. Parsec a => String -> Maybe a
simpleParsec

-- ------------------------------------------------------------
-- * Helpers for Documentation
-- ------------------------------------------------------------

relevantConfigValuesText :: [String] -> String
relevantConfigValuesText :: [String] -> String
relevantConfigValuesText [String]
vs =
     String
"Relevant global configuration keys:\n"
  forall a. [a] -> [a] -> [a]
++ forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [String
"  " forall a. [a] -> [a] -> [a]
++ String
v forall a. [a] -> [a] -> [a]
++ String
"\n" |String
v <- [String]
vs]