{-# LANGUAGE TemplateHaskell #-}

-- | Code that configures presentation parser for the CLI options
module Nix.Options.Parser where

import           Relude.Unsafe                  ( read )
import           GHC.Err                        ( errorWithoutStackTrace )
import           Data.Char                      ( isDigit )
import qualified Data.Text                     as Text
import           Data.Time                      ( UTCTime
                                                , defaultTimeLocale
                                                , parseTimeOrError
                                                )
import           Nix.Options
import           Options.Applicative     hiding ( ParserResult(..) )
import           Data.Version                   ( showVersion )
import           Development.GitRev             ( gitCommitDate
                                                , gitBranch
                                                , gitHash )
import           Paths_hnix                     ( version )

decodeVerbosity :: Int -> Verbosity
decodeVerbosity :: Int -> Verbosity
decodeVerbosity Int
0 = Verbosity
ErrorsOnly
decodeVerbosity Int
1 = Verbosity
Informational
decodeVerbosity Int
2 = Verbosity
Talkative
decodeVerbosity Int
3 = Verbosity
Chatty
decodeVerbosity Int
4 = Verbosity
DebugInfo
decodeVerbosity Int
_ = Verbosity
Vomit

argPair :: Mod OptionFields (Text, Text) -> Parser (Text, Text)
argPair :: Mod OptionFields (Text, Text) -> Parser (Text, Text)
argPair =
  ReadM (Text, Text)
-> Mod OptionFields (Text, Text) -> Parser (Text, Text)
forall a. ReadM a -> Mod OptionFields a -> Parser a
option (ReadM (Text, Text)
 -> Mod OptionFields (Text, Text) -> Parser (Text, Text))
-> ReadM (Text, Text)
-> Mod OptionFields (Text, Text)
-> Parser (Text, Text)
forall a b. (a -> b) -> a -> b
$
    do
      Text
s <- ReadM Text
forall s. IsString s => ReadM s
str
      ReadM (Text, Text)
-> (Int -> ReadM (Text, Text)) -> Maybe Int -> ReadM (Text, Text)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
        ([Char] -> ReadM (Text, Text)
forall a. [Char] -> a
errorWithoutStackTrace [Char]
"Format of --arg/--argstr in hnix is: name=expr")
        ((Text, Text) -> ReadM (Text, Text)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Text, Text) -> ReadM (Text, Text))
-> (Int -> (Text, Text)) -> Int -> ReadM (Text, Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Text) -> (Text, Text) -> (Text, Text)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second Text -> Text
Text.tail ((Text, Text) -> (Text, Text))
-> (Int -> (Text, Text)) -> Int -> (Text, Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Text -> (Text, Text)
`Text.splitAt` Text
s))
        ((Char -> Bool) -> Text -> Maybe Int
Text.findIndex (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'=') Text
s)

nixOptions :: UTCTime -> Parser Options
nixOptions :: UTCTime -> Parser Options
nixOptions UTCTime
current =
  Verbosity
-> Bool
-> Bool
-> Bool
-> Bool
-> Maybe [Char]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Maybe [Char]
-> Bool
-> Bool
-> Bool
-> Bool
-> Maybe Text
-> [[Char]]
-> Bool
-> Maybe [Char]
-> Bool
-> Bool
-> Bool
-> Maybe Text
-> [(Text, Text)]
-> [(Text, Text)]
-> Maybe [Char]
-> UTCTime
-> [[Char]]
-> Options
Options (Verbosity
 -> Bool
 -> Bool
 -> Bool
 -> Bool
 -> Maybe [Char]
 -> Bool
 -> Bool
 -> Bool
 -> Bool
 -> Bool
 -> Maybe [Char]
 -> Bool
 -> Bool
 -> Bool
 -> Bool
 -> Maybe Text
 -> [[Char]]
 -> Bool
 -> Maybe [Char]
 -> Bool
 -> Bool
 -> Bool
 -> Maybe Text
 -> [(Text, Text)]
 -> [(Text, Text)]
 -> Maybe [Char]
 -> UTCTime
 -> [[Char]]
 -> Options)
-> Parser Verbosity
-> Parser
     (Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    (Verbosity -> Maybe Verbosity -> Verbosity
forall a. a -> Maybe a -> a
fromMaybe Verbosity
Informational (Maybe Verbosity -> Verbosity)
-> Parser (Maybe Verbosity) -> Parser Verbosity
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
      Parser Verbosity -> Parser (Maybe Verbosity)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
        (ReadM Verbosity -> Mod OptionFields Verbosity -> Parser Verbosity
forall a. ReadM a -> Mod OptionFields a -> Parser a
option

          (do
            [Char]
a <- ReadM [Char]
forall s. IsString s => ReadM s
str
            ReadM Verbosity -> ReadM Verbosity -> Bool -> ReadM Verbosity
forall a. a -> a -> Bool -> a
bool
              ([Char] -> ReadM Verbosity
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"Argument to -v/--verbose must be a number")
              (Verbosity -> ReadM Verbosity
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Verbosity -> ReadM Verbosity) -> Verbosity -> ReadM Verbosity
forall a b. (a -> b) -> a -> b
$ Int -> Verbosity
decodeVerbosity (Int -> Verbosity) -> Int -> Verbosity
forall a b. (a -> b) -> a -> b
$ [Char] -> Int
forall a. Read a => [Char] -> a
read [Char]
a)
              ((Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isDigit [Char]
a)
          )

          (  Char -> Mod OptionFields Verbosity
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short Char
'v'
          Mod OptionFields Verbosity
-> Mod OptionFields Verbosity -> Mod OptionFields Verbosity
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields Verbosity
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"verbose"
          Mod OptionFields Verbosity
-> Mod OptionFields Verbosity -> Mod OptionFields Verbosity
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields Verbosity
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Verbose output"
          )

        )
      )
    Parser
  (Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Bool
      -> Bool
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"trace"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Enable tracing code (even more can be seen if built with --flags=tracing)"
        )
    Parser
  (Bool
   -> Bool
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Bool
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"thunks"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Enable reporting of thunk tracing as well as regular evaluation"
        )
    Parser
  (Bool
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"values"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Enable reporting of value provenance in error messages"
        )
    Parser
  (Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"scopes"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Enable reporting of scopes in evaluation traces"
        )
    Parser
  (Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser (Maybe [Char])
-> Parser
     (Bool
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser [Char] -> Parser (Maybe [Char])
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
        (Mod OptionFields [Char] -> Parser [Char]
forall s. IsString s => Mod OptionFields s -> Parser s
strOption
          (  [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"reduce"
          Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"When done evaluating, output the evaluated part of the expression to FILE"
          )
        )
    Parser
  (Bool
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"reduce-sets"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Reduce set members that aren't used; breaks if hasAttr is used"
        )
    Parser
  (Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Bool
      -> Bool
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"reduce-lists"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Reduce list members that aren't used; breaks if elemAt is used"
        )
    Parser
  (Bool
   -> Bool
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Bool
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"parse"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Whether to parse the file (also the default right now)"
        )
    Parser
  (Bool
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"parse-only"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Whether to parse only, no pretty printing or checking"
        )
    Parser
  (Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"find"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"If selected, find paths within attr trees"
        )
    Parser
  (Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser (Maybe [Char])
-> Parser
     (Bool
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser [Char] -> Parser (Maybe [Char])
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
        (Mod OptionFields [Char] -> Parser [Char]
forall s. IsString s => Mod OptionFields s -> Parser s
strOption
          (  [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"find-file"
          Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Look up the given files in Nix's search path"
          )
        )
    Parser
  (Bool
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"strict"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"When used with --eval, recursively evaluate list elements and attributes"
        )
    Parser
  (Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Bool
      -> Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"eval"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Whether to evaluate, or just pretty-print"
        )
    Parser
  (Bool
   -> Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Bool
      -> Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"json"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Print the resulting value as an JSON representation"
        )
    Parser
  (Bool
   -> Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Maybe Text
      -> [[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"xml"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Print the resulting value as an XML representation"
        )
    Parser
  (Maybe Text
   -> [[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser (Maybe Text)
-> Parser
     ([[Char]]
      -> Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Text -> Parser (Maybe Text)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
        (Mod OptionFields Text -> Parser Text
forall s. IsString s => Mod OptionFields s -> Parser s
strOption
          (  Char -> Mod OptionFields Text
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short Char
'A'
          Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields Text
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"attr"
          Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields Text
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Select an attribute from the top-level Nix expression being evaluated"
          )
        )
    Parser
  ([[Char]]
   -> Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser [[Char]]
-> Parser
     (Bool
      -> Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser [Char] -> Parser [[Char]]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many
        (Mod OptionFields [Char] -> Parser [Char]
forall s. IsString s => Mod OptionFields s -> Parser s
strOption
          (  Char -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short Char
'I'
          Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"include"
          Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Add a path to the Nix expression search path"
          )
        )
    Parser
  (Bool
   -> Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Maybe [Char]
      -> Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"check"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Whether to check for syntax fails after parsing"
        )
    Parser
  (Maybe [Char]
   -> Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser (Maybe [Char])
-> Parser
     (Bool
      -> Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser [Char] -> Parser (Maybe [Char])
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
        (Mod OptionFields [Char] -> Parser [Char]
forall s. IsString s => Mod OptionFields s -> Parser s
strOption
          (  [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"read"
          Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Read in an expression tree from a binary cache"
          )
        )
    Parser
  (Bool
   -> Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Bool
      -> Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"cache"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Write out the parsed expression tree to a binary cache"
        )
    Parser
  (Bool
   -> Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Bool
      -> Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"repl"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"After performing any indicated actions, enter the REPL"
        )
    Parser
  (Bool
   -> Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser Bool
-> Parser
     (Maybe Text
      -> [(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Mod FlagFields Bool -> Parser Bool
switch
        (  [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"ignore-fails"
        Mod FlagFields Bool -> Mod FlagFields Bool -> Mod FlagFields Bool
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod FlagFields Bool
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Continue parsing files, even if there are fails"
        )
    Parser
  (Maybe Text
   -> [(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser (Maybe Text)
-> Parser
     ([(Text, Text)]
      -> [(Text, Text)]
      -> Maybe [Char]
      -> UTCTime
      -> [[Char]]
      -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser Text -> Parser (Maybe Text)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
        (Mod OptionFields Text -> Parser Text
forall s. IsString s => Mod OptionFields s -> Parser s
strOption
          (  Char -> Mod OptionFields Text
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short Char
'E'
          Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields Text
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"expr"
          Mod OptionFields Text
-> Mod OptionFields Text -> Mod OptionFields Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields Text
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Expression to parse or evaluate")
        )
    Parser
  ([(Text, Text)]
   -> [(Text, Text)]
   -> Maybe [Char]
   -> UTCTime
   -> [[Char]]
   -> Options)
-> Parser [(Text, Text)]
-> Parser
     ([(Text, Text)] -> Maybe [Char] -> UTCTime -> [[Char]] -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Text, Text) -> Parser [(Text, Text)]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many
        (Mod OptionFields (Text, Text) -> Parser (Text, Text)
argPair
          (  [Char] -> Mod OptionFields (Text, Text)
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"arg"
          Mod OptionFields (Text, Text)
-> Mod OptionFields (Text, Text) -> Mod OptionFields (Text, Text)
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields (Text, Text)
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Argument to pass to an evaluated lambda")
        )
    Parser
  ([(Text, Text)] -> Maybe [Char] -> UTCTime -> [[Char]] -> Options)
-> Parser [(Text, Text)]
-> Parser (Maybe [Char] -> UTCTime -> [[Char]] -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Text, Text) -> Parser [(Text, Text)]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many
        (Mod OptionFields (Text, Text) -> Parser (Text, Text)
argPair
          (  [Char] -> Mod OptionFields (Text, Text)
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"argstr"
          Mod OptionFields (Text, Text)
-> Mod OptionFields (Text, Text) -> Mod OptionFields (Text, Text)
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields (Text, Text)
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Argument string to pass to an evaluated lambda"
          )
        )
    Parser (Maybe [Char] -> UTCTime -> [[Char]] -> Options)
-> Parser (Maybe [Char]) -> Parser (UTCTime -> [[Char]] -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser [Char] -> Parser (Maybe [Char])
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional
        (Mod OptionFields [Char] -> Parser [Char]
forall s. IsString s => Mod OptionFields s -> Parser s
strOption
          (  Char -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short Char
'f'
          Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"file"
          Mod OptionFields [Char]
-> Mod OptionFields [Char] -> Mod OptionFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Parse all of the files given in FILE; - means stdin"
          )
        )
    Parser (UTCTime -> [[Char]] -> Options)
-> Parser UTCTime -> Parser ([[Char]] -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ReadM UTCTime -> Mod OptionFields UTCTime -> Parser UTCTime
forall a. ReadM a -> Mod OptionFields a -> Parser a
option
        (Bool -> TimeLocale -> [Char] -> [Char] -> UTCTime
forall t.
ParseTime t =>
Bool -> TimeLocale -> [Char] -> [Char] -> t
parseTimeOrError Bool
True TimeLocale
defaultTimeLocale [Char]
"%Y/%m/%d %H:%M:%S" ([Char] -> UTCTime) -> ReadM [Char] -> ReadM UTCTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ReadM [Char]
forall s. IsString s => ReadM s
str)
        (  [Char] -> Mod OptionFields UTCTime
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"now"
        Mod OptionFields UTCTime
-> Mod OptionFields UTCTime -> Mod OptionFields UTCTime
forall a. Semigroup a => a -> a -> a
<> UTCTime -> Mod OptionFields UTCTime
forall (f :: * -> *) a. HasValue f => a -> Mod f a
value UTCTime
current
        Mod OptionFields UTCTime
-> Mod OptionFields UTCTime -> Mod OptionFields UTCTime
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields UTCTime
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Set current time for testing purposes"
        )
    Parser ([[Char]] -> Options) -> Parser [[Char]] -> Parser Options
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser [Char] -> Parser [[Char]]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many
        (Mod ArgumentFields [Char] -> Parser [Char]
forall s. IsString s => Mod ArgumentFields s -> Parser s
strArgument
          (  [Char] -> Mod ArgumentFields [Char]
forall (f :: * -> *) a. HasMetavar f => [Char] -> Mod f a
metavar [Char]
"FILE"
          Mod ArgumentFields [Char]
-> Mod ArgumentFields [Char] -> Mod ArgumentFields [Char]
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod ArgumentFields [Char]
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Path of file to parse"
          )
        )

--  2020-09-12: CLI --version option mechanism is tied to meta modules specificly generated by Cabal. It is possible to use Template Haskell to resolve the version, as also a g
versionOpt :: Parser (a -> a)
versionOpt :: Parser (a -> a)
versionOpt = Parser ((a -> a) -> a -> a)
forall a. Parser (a -> a)
shortVersionOpt Parser ((a -> a) -> a -> a) -> Parser (a -> a) -> Parser (a -> a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (a -> a)
forall a. Parser (a -> a)
debugVersionOpt
 where
  shortVersionOpt :: Parser (a -> a)
  shortVersionOpt :: Parser (a -> a)
shortVersionOpt =
    [Char] -> Mod OptionFields (a -> a) -> Parser (a -> a)
forall a. [Char] -> Mod OptionFields (a -> a) -> Parser (a -> a)
infoOption
      (Version -> [Char]
showVersion Version
version)
      (  [Char] -> Mod OptionFields (a -> a)
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"version"
      Mod OptionFields (a -> a)
-> Mod OptionFields (a -> a) -> Mod OptionFields (a -> a)
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields (a -> a)
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Show release version"
      )

  --  2020-09-13: NOTE: Does not work for direct `nix-build`s, works for `nix-shell` `cabal` builds.
  debugVersionOpt :: Parser (a -> a)
  debugVersionOpt :: Parser (a -> a)
debugVersionOpt =
    [Char] -> Mod OptionFields (a -> a) -> Parser (a -> a)
forall a. [Char] -> Mod OptionFields (a -> a) -> Parser (a -> a)
infoOption
      ( [[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat
          [ [Char]
"Version: ", Version -> [Char]
showVersion Version
version
          , [Char]
"\nCommit: ", $([Char]
gitHash)
          , [Char]
"\n  date: ", $([Char]
gitCommitDate)
          , [Char]
"\n  branch: ", $([Char]
gitBranch)
          ]
      )
      (  [Char] -> Mod OptionFields (a -> a)
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long [Char]
"long-version"
      Mod OptionFields (a -> a)
-> Mod OptionFields (a -> a) -> Mod OptionFields (a -> a)
forall a. Semigroup a => a -> a -> a
<> [Char] -> Mod OptionFields (a -> a)
forall (f :: * -> *) a. [Char] -> Mod f a
help [Char]
"Show long debug version form"
      )

nixOptionsInfo :: UTCTime -> ParserInfo Options
nixOptionsInfo :: UTCTime -> ParserInfo Options
nixOptionsInfo UTCTime
current =
  Parser Options -> InfoMod Options -> ParserInfo Options
forall a. Parser a -> InfoMod a -> ParserInfo a
info
    (Parser ((Options -> Options) -> Options -> Options)
forall a. Parser (a -> a)
helper Parser ((Options -> Options) -> Options -> Options)
-> Parser (Options -> Options) -> Parser (Options -> Options)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Parser (Options -> Options)
forall a. Parser (a -> a)
versionOpt Parser (Options -> Options) -> Parser Options -> Parser Options
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> UTCTime -> Parser Options
nixOptions UTCTime
current)
    (InfoMod Options
forall a. InfoMod a
fullDesc InfoMod Options -> InfoMod Options -> InfoMod Options
forall a. Semigroup a => a -> a -> a
<> [Char] -> InfoMod Options
forall a. [Char] -> InfoMod a
progDesc [Char]
"" InfoMod Options -> InfoMod Options -> InfoMod Options
forall a. Semigroup a => a -> a -> a
<> [Char] -> InfoMod Options
forall a. [Char] -> InfoMod a
header [Char]
"hnix")