{-# LANGUAGE TemplateHaskell #-}

module Nix.Options.Parser where

import           Control.Arrow                  ( second )
import           Data.Char                      ( isDigit )
import           Data.Maybe                     ( fromMaybe )
import           Data.Text                      ( Text )
import qualified Data.Text                     as Text
import           Data.Time
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 0 = Verbosity
ErrorsOnly
decodeVerbosity 1 = Verbosity
Informational
decodeVerbosity 2 = Verbosity
Talkative
decodeVerbosity 3 = Verbosity
Chatty
decodeVerbosity 4 = Verbosity
DebugInfo
decodeVerbosity _ = 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
$ ReadM Text
forall s. IsString s => ReadM s
str ReadM Text -> (Text -> ReadM (Text, Text)) -> ReadM (Text, Text)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \s :: Text
s -> case (Char -> Bool) -> Text -> Maybe Int
Text.findIndex (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '=') Text
s of
  Nothing ->
    [Char] -> ReadM (Text, Text)
forall a. [Char] -> a
errorWithoutStackTrace "Format of --arg/--argstr in hnix is: name=expr"
  Just i :: Int
i -> (Text, Text) -> ReadM (Text, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return ((Text, Text) -> ReadM (Text, Text))
-> (Text, Text) -> ReadM (Text, Text)
forall a b. (a -> b) -> a -> b
$ (Text -> Text) -> (Text, Text) -> (Text, Text)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second Text -> Text
Text.tail ((Text, Text) -> (Text, Text)) -> (Text, Text) -> (Text, Text)
forall a b. (a -> b) -> a -> b
$ Int -> Text -> (Text, Text)
Text.splitAt Int
i Text
s

nixOptions :: UTCTime -> Parser Options
nixOptions :: UTCTime -> Parser Options
nixOptions current :: 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
              if (Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isDigit [Char]
a
                then 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 ([Char] -> Int
forall a. Read a => [Char] -> a
read [Char]
a)
                else [Char] -> ReadM Verbosity
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail "Argument to -v/--verbose must be a number"
            )

            (  Char -> Mod OptionFields Verbosity
forall (f :: * -> *) a. HasName f => Char -> Mod f a
short '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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 "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 '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 "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 "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 '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 "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 "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 "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 "Whether to check for syntax errors 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 "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 "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 "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 "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 "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 "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 "ignore-errors"
        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 "Continue parsing files, even if there are errors"
        )
    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 '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 "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 "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 "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 "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 "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 "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 '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 "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 "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 "%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 "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 "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 "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 "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 "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 "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
        [ "Version: ", Version -> [Char]
showVersion Version
version
        , "\nCommit: ", $(gitHash)
        , "\n  date: ", $(gitCommitDate)
        , "\n  branch: ", $(gitBranch)
        ]
    )
    (  [Char] -> Mod OptionFields (a -> a)
forall (f :: * -> *) a. HasName f => [Char] -> Mod f a
long "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 "Show long debug version form"
    )

nixOptionsInfo :: UTCTime -> ParserInfo Options
nixOptionsInfo :: UTCTime -> ParserInfo Options
nixOptionsInfo current :: 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 "" InfoMod Options -> InfoMod Options -> InfoMod Options
forall a. Semigroup a => a -> a -> a
<> [Char] -> InfoMod Options
forall a. [Char] -> InfoMod a
header "hnix")