{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE OverloadedStrings   #-}
{-# LANGUAGE CPP                 #-}
{-# LANGUAGE DeriveGeneric       #-}
{-# LANGUAGE TemplateHaskell     #-}
{-# LANGUAGE FlexibleInstances   #-}
{-# LANGUAGE FlexibleContexts    #-}
{- |
   Module      : Text.Pandoc.App.Opt
   Copyright   : Copyright (C) 2006-2021 John MacFarlane
   License     : GNU GPL, version 2 or above

   Maintainer  : John MacFarlane <jgm@berkeley@edu>
   Stability   : alpha
   Portability : portable

Options for pandoc when used as an app.
-}
module Text.Pandoc.App.Opt (
            Opt(..)
          , LineEnding (..)
          , IpynbOutput (..)
          , DefaultsState (..)
          , defaultOpts
          , applyDefaults
          , fullDefaultsPath
          ) where
import Control.Monad.Except (MonadIO, liftIO, throwError, (>=>), foldM)
import Control.Monad.State.Strict (StateT, modify, gets)
import System.FilePath ( addExtension, (</>), takeExtension, takeDirectory )
import System.Directory ( canonicalizePath )
import Data.Char (toLower)
import Data.Maybe (fromMaybe)
import GHC.Generics hiding (Meta)
import Text.Pandoc.Filter (Filter (..))
import Text.Pandoc.Logging (Verbosity (WARNING), LogMessage(..))
import Text.Pandoc.Options (TopLevelDivision (TopLevelDefault),
                            TrackChanges (AcceptChanges),
                            WrapOption (WrapAuto), HTMLMathMethod (PlainMath),
                            ReferenceLocation (EndOfDocument),
                            ObfuscationMethod (NoObfuscation),
                            CiteMethod (Citeproc))
import Text.Pandoc.Class (readFileStrict, fileExists, setVerbosity, report,
                          PandocMonad(lookupEnv), getUserDataDir)
import Text.Pandoc.Error (PandocError (PandocParseError, PandocSomeError))
import Text.Pandoc.Shared (defaultUserDataDir, findM, ordNub)
import qualified Text.Pandoc.Parsing as P
import Text.Pandoc.Readers.Metadata (yamlMap)
import Text.Pandoc.Class.PandocPure
import Text.DocTemplates (Context(..))
import Data.Text (Text, unpack)
import Data.Default (def)
import qualified Data.Text as T
import qualified Data.Map as M
import Text.Pandoc.Definition (Meta(..), MetaValue(..))
import Data.Aeson (defaultOptions, Options(..), Result(..), fromJSON, camelTo2)
import Data.Aeson.TH (deriveJSON)
import Control.Applicative ((<|>))
import Data.Yaml

-- | The type of line-endings to be used when writing plain-text.
data LineEnding = LF | CRLF | Native deriving (Int -> LineEnding -> ShowS
[LineEnding] -> ShowS
LineEnding -> String
(Int -> LineEnding -> ShowS)
-> (LineEnding -> String)
-> ([LineEnding] -> ShowS)
-> Show LineEnding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LineEnding] -> ShowS
$cshowList :: [LineEnding] -> ShowS
show :: LineEnding -> String
$cshow :: LineEnding -> String
showsPrec :: Int -> LineEnding -> ShowS
$cshowsPrec :: Int -> LineEnding -> ShowS
Show, (forall x. LineEnding -> Rep LineEnding x)
-> (forall x. Rep LineEnding x -> LineEnding) -> Generic LineEnding
forall x. Rep LineEnding x -> LineEnding
forall x. LineEnding -> Rep LineEnding x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LineEnding x -> LineEnding
$cfrom :: forall x. LineEnding -> Rep LineEnding x
Generic)

-- see https://github.com/jgm/pandoc/pull/4083
-- using generic deriving caused long compilation times
$(deriveJSON
   defaultOptions{ constructorTagModifier = map toLower } ''LineEnding)

-- | How to handle output blocks in ipynb.
data IpynbOutput =
    IpynbOutputAll
  | IpynbOutputNone
  | IpynbOutputBest
  deriving (Int -> IpynbOutput -> ShowS
[IpynbOutput] -> ShowS
IpynbOutput -> String
(Int -> IpynbOutput -> ShowS)
-> (IpynbOutput -> String)
-> ([IpynbOutput] -> ShowS)
-> Show IpynbOutput
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IpynbOutput] -> ShowS
$cshowList :: [IpynbOutput] -> ShowS
show :: IpynbOutput -> String
$cshow :: IpynbOutput -> String
showsPrec :: Int -> IpynbOutput -> ShowS
$cshowsPrec :: Int -> IpynbOutput -> ShowS
Show, (forall x. IpynbOutput -> Rep IpynbOutput x)
-> (forall x. Rep IpynbOutput x -> IpynbOutput)
-> Generic IpynbOutput
forall x. Rep IpynbOutput x -> IpynbOutput
forall x. IpynbOutput -> Rep IpynbOutput x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep IpynbOutput x -> IpynbOutput
$cfrom :: forall x. IpynbOutput -> Rep IpynbOutput x
Generic)

$(deriveJSON
   defaultOptions{ fieldLabelModifier = map toLower . drop 11 } ''IpynbOutput)

-- | Data structure for command line options.
data Opt = Opt
    { Opt -> Int
optTabStop               :: Int     -- ^ Number of spaces per tab
    , Opt -> Bool
optPreserveTabs          :: Bool    -- ^ Preserve tabs instead of converting to spaces
    , Opt -> Bool
optStandalone            :: Bool    -- ^ Include header, footer
    , Opt -> Maybe Text
optFrom                  :: Maybe Text  -- ^ Reader format
    , Opt -> Maybe Text
optTo                    :: Maybe Text  -- ^ Writer format
    , Opt -> Bool
optTableOfContents       :: Bool    -- ^ Include table of contents
    , Opt -> Int
optShiftHeadingLevelBy   :: Int     -- ^ Shift heading level by
    , Opt -> Maybe String
optTemplate              :: Maybe FilePath  -- ^ Custom template
    , Opt -> Context Text
optVariables             :: Context Text    -- ^ Template variables to set
    , Opt -> Meta
optMetadata              :: Meta -- ^ Metadata fields to set
    , Opt -> [String]
optMetadataFiles         :: [FilePath]  -- ^ Name of YAML metadata files
    , Opt -> Maybe String
optOutputFile            :: Maybe FilePath  -- ^ Name of output file
    , Opt -> Maybe [String]
optInputFiles            :: Maybe [FilePath] -- ^ Names of input files
    , Opt -> Bool
optNumberSections        :: Bool    -- ^ Number sections in LaTeX
    , Opt -> [Int]
optNumberOffset          :: [Int]   -- ^ Starting number for sections
    , Opt -> Bool
optSectionDivs           :: Bool    -- ^ Put sections in div tags in HTML
    , Opt -> Bool
optIncremental           :: Bool    -- ^ Use incremental lists in Slidy/Slideous/S5
    , Opt -> Bool
optSelfContained         :: Bool    -- ^ Make HTML accessible offline
    , Opt -> Bool
optHtmlQTags             :: Bool    -- ^ Use <q> tags in HTML
    , Opt -> Maybe Text
optHighlightStyle        :: Maybe Text -- ^ Style to use for highlighted code
    , Opt -> [String]
optSyntaxDefinitions     :: [FilePath]  -- ^ xml syntax defs to load
    , Opt -> TopLevelDivision
optTopLevelDivision      :: TopLevelDivision -- ^ Type of the top-level divisions
    , Opt -> HTMLMathMethod
optHTMLMathMethod        :: HTMLMathMethod -- ^ Method to print HTML math
    , Opt -> Maybe String
optAbbreviations         :: Maybe FilePath -- ^ Path to abbrevs file
    , Opt -> Maybe String
optReferenceDoc          :: Maybe FilePath -- ^ Path of reference doc
    , Opt -> String
optEpubSubdirectory      :: String -- ^ EPUB subdir in OCF container
    , Opt -> Maybe String
optEpubMetadata          :: Maybe FilePath   -- ^ EPUB metadata
    , Opt -> [String]
optEpubFonts             :: [FilePath] -- ^ EPUB fonts to embed
    , Opt -> Int
optEpubChapterLevel      :: Int     -- ^ Header level at which to split chapters
    , Opt -> Maybe String
optEpubCoverImage        :: Maybe FilePath -- ^ Cover image for epub
    , Opt -> Int
optTOCDepth              :: Int     -- ^ Number of levels to include in TOC
    , Opt -> Bool
optDumpArgs              :: Bool    -- ^ Output command-line arguments
    , Opt -> Bool
optIgnoreArgs            :: Bool    -- ^ Ignore command-line arguments
    , Opt -> Verbosity
optVerbosity             :: Verbosity  -- ^ Verbosity of diagnostic output
    , Opt -> Bool
optTrace                 :: Bool  -- ^ Enable tracing
    , Opt -> Maybe String
optLogFile               :: Maybe FilePath -- ^ File to write JSON log output
    , Opt -> Bool
optFailIfWarnings        :: Bool    -- ^ Fail on warnings
    , Opt -> Bool
optReferenceLinks        :: Bool    -- ^ Use reference links in writing markdown, rst
    , Opt -> ReferenceLocation
optReferenceLocation     :: ReferenceLocation -- ^ location for footnotes and link references in markdown output
    , Opt -> Int
optDpi                   :: Int     -- ^ Dpi
    , Opt -> WrapOption
optWrap                  :: WrapOption  -- ^ Options for wrapping text
    , Opt -> Int
optColumns               :: Int     -- ^ Line length in characters
    , Opt -> [Filter]
optFilters               :: [Filter] -- ^ Filters to apply
    , Opt -> ObfuscationMethod
optEmailObfuscation      :: ObfuscationMethod
    , Opt -> Text
optIdentifierPrefix      :: Text
    , Opt -> Bool
optStripEmptyParagraphs  :: Bool -- ^ Strip empty paragraphs
    , Opt -> [Text]
optIndentedCodeClasses   :: [Text] -- ^ Default classes for indented code blocks
    , Opt -> Maybe String
optDataDir               :: Maybe FilePath
    , Opt -> CiteMethod
optCiteMethod            :: CiteMethod -- ^ Method to output cites
    , Opt -> Bool
optListings              :: Bool       -- ^ Use listings package for code blocks
    , Opt -> Maybe String
optPdfEngine             :: Maybe String -- ^ Program to use for latex/html -> pdf
    , Opt -> [String]
optPdfEngineOpts         :: [String]   -- ^ Flags to pass to the engine
    , Opt -> Maybe Int
optSlideLevel            :: Maybe Int  -- ^ Header level that creates slides
    , Opt -> Bool
optSetextHeaders         :: Bool       -- ^ Use atx headers for markdown level 1-2
    , Opt -> Bool
optAscii                 :: Bool       -- ^ Prefer ascii output
    , Opt -> Text
optDefaultImageExtension :: Text       -- ^ Default image extension
    , Opt -> Maybe String
optExtractMedia          :: Maybe FilePath -- ^ Path to extract embedded media
    , Opt -> TrackChanges
optTrackChanges          :: TrackChanges -- ^ Accept or reject MS Word track-changes.
    , Opt -> Bool
optFileScope             :: Bool         -- ^ Parse input files before combining
    , Opt -> Maybe Text
optTitlePrefix           :: Maybe Text     -- ^ Prefix for title
    , Opt -> [String]
optCss                   :: [FilePath]       -- ^ CSS files to link to
    , Opt -> IpynbOutput
optIpynbOutput           :: IpynbOutput      -- ^ How to treat ipynb output blocks
    , Opt -> [String]
optIncludeBeforeBody     :: [FilePath]       -- ^ Files to include before
    , Opt -> [String]
optIncludeAfterBody      :: [FilePath]       -- ^ Files to include after body
    , Opt -> [String]
optIncludeInHeader       :: [FilePath]       -- ^ Files to include in header
    , Opt -> [String]
optResourcePath          :: [FilePath] -- ^ Path to search for images etc
    , Opt -> [(Text, Text)]
optRequestHeaders        :: [(Text, Text)] -- ^ Headers for HTTP requests
    , Opt -> Bool
optNoCheckCertificate    :: Bool       -- ^ Disable certificate validation
    , Opt -> LineEnding
optEol                   :: LineEnding -- ^ Style of line-endings to use
    , Opt -> Bool
optStripComments         :: Bool       -- ^ Skip HTML comments
    , Opt -> Maybe String
optCSL                   :: Maybe FilePath -- ^ CSL stylesheet
    , Opt -> [String]
optBibliography          :: [FilePath]  -- ^ Bibliography files
    , Opt -> Maybe String
optCitationAbbreviations :: Maybe FilePath -- ^ Citation abbreviations
    , Opt -> Bool
optSandbox               :: Bool
    } deriving ((forall x. Opt -> Rep Opt x)
-> (forall x. Rep Opt x -> Opt) -> Generic Opt
forall x. Rep Opt x -> Opt
forall x. Opt -> Rep Opt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Opt x -> Opt
$cfrom :: forall x. Opt -> Rep Opt x
Generic, Int -> Opt -> ShowS
[Opt] -> ShowS
Opt -> String
(Int -> Opt -> ShowS)
-> (Opt -> String) -> ([Opt] -> ShowS) -> Show Opt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Opt] -> ShowS
$cshowList :: [Opt] -> ShowS
show :: Opt -> String
$cshow :: Opt -> String
showsPrec :: Int -> Opt -> ShowS
$cshowsPrec :: Int -> Opt -> ShowS
Show)

$(deriveJSON
   defaultOptions{ fieldLabelModifier = camelTo2 '-' . drop 3 } ''Opt)

instance FromJSON (Opt -> Opt) where
  parseJSON :: Value -> Parser (Opt -> Opt)
parseJSON (Object Object
m) =
    case Value -> Result (Map Text Value)
forall a. FromJSON a => Value -> Result a
fromJSON (Object -> Value
Object Object
m) of
      Error String
err' -> String -> Parser (Opt -> Opt)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
err'
      Success (Map Text Value
m' :: M.Map Text Value) -> ((Text, Value) -> Parser (Opt -> Opt))
-> [(Text, Value)] -> Parser (Opt -> Opt)
forall (m :: * -> *) a b.
Monad m =>
(a -> m (b -> b)) -> [a] -> m (b -> b)
chain (Text, Value) -> Parser (Opt -> Opt)
doOpt (Map Text Value -> [(Text, Value)]
forall k a. Map k a -> [(k, a)]
M.toList Map Text Value
m')
  parseJSON Value
_ = String -> Parser (Opt -> Opt)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Expected a mapping"

data DefaultsState = DefaultsState
    {
      DefaultsState -> Maybe String
curDefaults      :: Maybe FilePath -- currently parsed file
    , DefaultsState -> [[String]]
inheritanceGraph :: [[FilePath]]   -- defaults file inheritance graph
    } deriving (Int -> DefaultsState -> ShowS
[DefaultsState] -> ShowS
DefaultsState -> String
(Int -> DefaultsState -> ShowS)
-> (DefaultsState -> String)
-> ([DefaultsState] -> ShowS)
-> Show DefaultsState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DefaultsState] -> ShowS
$cshowList :: [DefaultsState] -> ShowS
show :: DefaultsState -> String
$cshow :: DefaultsState -> String
showsPrec :: Int -> DefaultsState -> ShowS
$cshowsPrec :: Int -> DefaultsState -> ShowS
Show)

instance (PandocMonad m, MonadIO m)
      => FromJSON (Opt -> StateT DefaultsState m Opt) where
  parseJSON :: Value -> Parser (Opt -> StateT DefaultsState m Opt)
parseJSON (Object Object
o) =
    case Value -> Result (Map Text Value)
forall a. FromJSON a => Value -> Result a
fromJSON (Object -> Value
Object Object
o) of
      Error String
err' -> String -> Parser (Opt -> StateT DefaultsState m Opt)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
err'
      Success (Map Text Value
opts :: M.Map Text Value) -> do
        Maybe String
dataDir <- case Text -> Map Text Value -> Maybe Value
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
"data-dir" Map Text Value
opts of
          Maybe Value
Nothing -> Maybe String -> Parser (Maybe String)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe String
forall a. Maybe a
Nothing
          Just Value
v -> String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String)
-> (Text -> String) -> Text -> Maybe String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
unpack (Text -> Maybe String) -> Parser Text -> Parser (Maybe String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
        Opt -> StateT DefaultsState m Opt
f <- [(Text, Value)] -> Parser (Opt -> StateT DefaultsState m Opt)
forall (m :: * -> *).
Monad m =>
[(Text, Value)] -> Parser (Opt -> StateT DefaultsState m Opt)
parseOptions (Map Text Value -> [(Text, Value)]
forall k a. Map k a -> [(k, a)]
M.toList Map Text Value
opts)
        case Text -> Map Text Value -> Maybe Value
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
"defaults" Map Text Value
opts of
          Just Value
v -> do
            Opt -> StateT DefaultsState m Opt
g <- Value -> Maybe String -> Parser (Opt -> StateT DefaultsState m Opt)
forall (m :: * -> *).
(PandocMonad m, MonadIO m) =>
Value -> Maybe String -> Parser (Opt -> StateT DefaultsState m Opt)
parseDefaults Value
v Maybe String
dataDir
            (Opt -> StateT DefaultsState m Opt)
-> Parser (Opt -> StateT DefaultsState m Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return  ((Opt -> StateT DefaultsState m Opt)
 -> Parser (Opt -> StateT DefaultsState m Opt))
-> (Opt -> StateT DefaultsState m Opt)
-> Parser (Opt -> StateT DefaultsState m Opt)
forall a b. (a -> b) -> a -> b
$ Opt -> StateT DefaultsState m Opt
g (Opt -> StateT DefaultsState m Opt)
-> (Opt -> StateT DefaultsState m Opt)
-> Opt
-> StateT DefaultsState m Opt
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Opt -> StateT DefaultsState m Opt
f (Opt -> StateT DefaultsState m Opt)
-> (Opt -> StateT DefaultsState m Opt)
-> Opt
-> StateT DefaultsState m Opt
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Opt -> StateT DefaultsState m Opt
forall (m :: * -> *).
(PandocMonad m, MonadIO m) =>
Opt -> StateT DefaultsState m Opt
resolveVarsInOpt
          Maybe Value
Nothing -> (Opt -> StateT DefaultsState m Opt)
-> Parser (Opt -> StateT DefaultsState m Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return ((Opt -> StateT DefaultsState m Opt)
 -> Parser (Opt -> StateT DefaultsState m Opt))
-> (Opt -> StateT DefaultsState m Opt)
-> Parser (Opt -> StateT DefaultsState m Opt)
forall a b. (a -> b) -> a -> b
$ Opt -> StateT DefaultsState m Opt
f (Opt -> StateT DefaultsState m Opt)
-> (Opt -> StateT DefaultsState m Opt)
-> Opt
-> StateT DefaultsState m Opt
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Opt -> StateT DefaultsState m Opt
forall (m :: * -> *).
(PandocMonad m, MonadIO m) =>
Opt -> StateT DefaultsState m Opt
resolveVarsInOpt
  parseJSON Value
_ = String -> Parser (Opt -> StateT DefaultsState m Opt)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Expected a mapping"

resolveVarsInOpt :: forall m. (PandocMonad m, MonadIO m)
                 => Opt -> StateT DefaultsState m Opt
resolveVarsInOpt :: Opt -> StateT DefaultsState m Opt
resolveVarsInOpt
    opt :: Opt
opt@Opt
    { optTemplate :: Opt -> Maybe String
optTemplate              = Maybe String
oTemplate
    , optMetadataFiles :: Opt -> [String]
optMetadataFiles         = [String]
oMetadataFiles
    , optOutputFile :: Opt -> Maybe String
optOutputFile            = Maybe String
oOutputFile
    , optInputFiles :: Opt -> Maybe [String]
optInputFiles            = Maybe [String]
oInputFiles
    , optSyntaxDefinitions :: Opt -> [String]
optSyntaxDefinitions     = [String]
oSyntaxDefinitions
    , optAbbreviations :: Opt -> Maybe String
optAbbreviations         = Maybe String
oAbbreviations
    , optReferenceDoc :: Opt -> Maybe String
optReferenceDoc          = Maybe String
oReferenceDoc
    , optEpubMetadata :: Opt -> Maybe String
optEpubMetadata          = Maybe String
oEpubMetadata
    , optEpubFonts :: Opt -> [String]
optEpubFonts             = [String]
oEpubFonts
    , optEpubCoverImage :: Opt -> Maybe String
optEpubCoverImage        = Maybe String
oEpubCoverImage
    , optLogFile :: Opt -> Maybe String
optLogFile               = Maybe String
oLogFile
    , optFilters :: Opt -> [Filter]
optFilters               = [Filter]
oFilters
    , optDataDir :: Opt -> Maybe String
optDataDir               = Maybe String
oDataDir
    , optExtractMedia :: Opt -> Maybe String
optExtractMedia          = Maybe String
oExtractMedia
    , optCss :: Opt -> [String]
optCss                   = [String]
oCss
    , optIncludeBeforeBody :: Opt -> [String]
optIncludeBeforeBody     = [String]
oIncludeBeforeBody
    , optIncludeAfterBody :: Opt -> [String]
optIncludeAfterBody      = [String]
oIncludeAfterBody
    , optIncludeInHeader :: Opt -> [String]
optIncludeInHeader       = [String]
oIncludeInHeader
    , optResourcePath :: Opt -> [String]
optResourcePath          = [String]
oResourcePath
    , optCSL :: Opt -> Maybe String
optCSL                   = Maybe String
oCSL
    , optBibliography :: Opt -> [String]
optBibliography          = [String]
oBibliography
    , optCitationAbbreviations :: Opt -> Maybe String
optCitationAbbreviations = Maybe String
oCitationAbbreviations
    }
  = do
      Maybe String
oTemplate' <- (String -> StateT DefaultsState m String)
-> Maybe String -> StateT DefaultsState m (Maybe String)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars Maybe String
oTemplate
      [String]
oMetadataFiles' <- (String -> StateT DefaultsState m String)
-> [String] -> StateT DefaultsState m [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars [String]
oMetadataFiles
      Maybe String
oOutputFile' <- (String -> StateT DefaultsState m String)
-> Maybe String -> StateT DefaultsState m (Maybe String)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars Maybe String
oOutputFile
      Maybe [String]
oInputFiles' <- ([String] -> StateT DefaultsState m [String])
-> Maybe [String] -> StateT DefaultsState m (Maybe [String])
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((String -> StateT DefaultsState m String)
-> [String] -> StateT DefaultsState m [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars) Maybe [String]
oInputFiles
      [String]
oSyntaxDefinitions' <- (String -> StateT DefaultsState m String)
-> [String] -> StateT DefaultsState m [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars [String]
oSyntaxDefinitions
      Maybe String
oAbbreviations' <- (String -> StateT DefaultsState m String)
-> Maybe String -> StateT DefaultsState m (Maybe String)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars Maybe String
oAbbreviations
      Maybe String
oReferenceDoc' <- (String -> StateT DefaultsState m String)
-> Maybe String -> StateT DefaultsState m (Maybe String)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars Maybe String
oReferenceDoc
      Maybe String
oEpubMetadata' <- (String -> StateT DefaultsState m String)
-> Maybe String -> StateT DefaultsState m (Maybe String)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars Maybe String
oEpubMetadata
      [String]
oEpubFonts' <- (String -> StateT DefaultsState m String)
-> [String] -> StateT DefaultsState m [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars [String]
oEpubFonts
      Maybe String
oEpubCoverImage' <- (String -> StateT DefaultsState m String)
-> Maybe String -> StateT DefaultsState m (Maybe String)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars Maybe String
oEpubCoverImage
      Maybe String
oLogFile' <- (String -> StateT DefaultsState m String)
-> Maybe String -> StateT DefaultsState m (Maybe String)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars Maybe String
oLogFile
      [Filter]
oFilters' <- (Filter -> StateT DefaultsState m Filter)
-> [Filter] -> StateT DefaultsState m [Filter]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Filter -> StateT DefaultsState m Filter
resolveVarsInFilter [Filter]
oFilters
      Maybe String
oDataDir' <- (String -> StateT DefaultsState m String)
-> Maybe String -> StateT DefaultsState m (Maybe String)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars Maybe String
oDataDir
      Maybe String
oExtractMedia' <- (String -> StateT DefaultsState m String)
-> Maybe String -> StateT DefaultsState m (Maybe String)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars Maybe String
oExtractMedia
      [String]
oCss' <- (String -> StateT DefaultsState m String)
-> [String] -> StateT DefaultsState m [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars [String]
oCss
      [String]
oIncludeBeforeBody' <- (String -> StateT DefaultsState m String)
-> [String] -> StateT DefaultsState m [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars [String]
oIncludeBeforeBody
      [String]
oIncludeAfterBody' <- (String -> StateT DefaultsState m String)
-> [String] -> StateT DefaultsState m [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars [String]
oIncludeAfterBody
      [String]
oIncludeInHeader' <- (String -> StateT DefaultsState m String)
-> [String] -> StateT DefaultsState m [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars [String]
oIncludeInHeader
      [String]
oResourcePath' <- (String -> StateT DefaultsState m String)
-> [String] -> StateT DefaultsState m [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars [String]
oResourcePath
      Maybe String
oCSL' <- (String -> StateT DefaultsState m String)
-> Maybe String -> StateT DefaultsState m (Maybe String)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars Maybe String
oCSL
      [String]
oBibliography' <- (String -> StateT DefaultsState m String)
-> [String] -> StateT DefaultsState m [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars [String]
oBibliography
      Maybe String
oCitationAbbreviations' <- (String -> StateT DefaultsState m String)
-> Maybe String -> StateT DefaultsState m (Maybe String)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars Maybe String
oCitationAbbreviations
      Opt -> StateT DefaultsState m Opt
forall (m :: * -> *) a. Monad m => a -> m a
return Opt
opt{ optTemplate :: Maybe String
optTemplate              = Maybe String
oTemplate'
                , optMetadataFiles :: [String]
optMetadataFiles         = [String]
oMetadataFiles'
                , optOutputFile :: Maybe String
optOutputFile            = Maybe String
oOutputFile'
                , optInputFiles :: Maybe [String]
optInputFiles            = Maybe [String]
oInputFiles'
                , optSyntaxDefinitions :: [String]
optSyntaxDefinitions     = [String]
oSyntaxDefinitions'
                , optAbbreviations :: Maybe String
optAbbreviations         = Maybe String
oAbbreviations'
                , optReferenceDoc :: Maybe String
optReferenceDoc          = Maybe String
oReferenceDoc'
                , optEpubMetadata :: Maybe String
optEpubMetadata          = Maybe String
oEpubMetadata'
                , optEpubFonts :: [String]
optEpubFonts             = [String]
oEpubFonts'
                , optEpubCoverImage :: Maybe String
optEpubCoverImage        = Maybe String
oEpubCoverImage'
                , optLogFile :: Maybe String
optLogFile               = Maybe String
oLogFile'
                , optFilters :: [Filter]
optFilters               = [Filter]
oFilters'
                , optDataDir :: Maybe String
optDataDir               = Maybe String
oDataDir'
                , optExtractMedia :: Maybe String
optExtractMedia          = Maybe String
oExtractMedia'
                , optCss :: [String]
optCss                   = [String]
oCss'
                , optIncludeBeforeBody :: [String]
optIncludeBeforeBody     = [String]
oIncludeBeforeBody'
                , optIncludeAfterBody :: [String]
optIncludeAfterBody      = [String]
oIncludeAfterBody'
                , optIncludeInHeader :: [String]
optIncludeInHeader       = [String]
oIncludeInHeader'
                , optResourcePath :: [String]
optResourcePath          = [String]
oResourcePath'
                , optCSL :: Maybe String
optCSL                   = Maybe String
oCSL'
                , optBibliography :: [String]
optBibliography          = [String]
oBibliography'
                , optCitationAbbreviations :: Maybe String
optCitationAbbreviations = Maybe String
oCitationAbbreviations'
                }

 where
  resolveVars :: FilePath -> StateT DefaultsState m FilePath
  resolveVars :: String -> StateT DefaultsState m String
resolveVars [] = String -> StateT DefaultsState m String
forall (m :: * -> *) a. Monad m => a -> m a
return []
  resolveVars (Char
'$':Char
'{':String
xs) =
    let (String
ys, String
zs) = (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
'}') String
xs
     in if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
zs
           then String -> StateT DefaultsState m String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> StateT DefaultsState m String)
-> String -> StateT DefaultsState m String
forall a b. (a -> b) -> a -> b
$ Char
'$'Char -> ShowS
forall a. a -> [a] -> [a]
:Char
'{'Char -> ShowS
forall a. a -> [a] -> [a]
:String
xs
           else do
             String
val <- String -> StateT DefaultsState m String
lookupEnv' String
ys
             (String
val String -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS
-> StateT DefaultsState m String -> StateT DefaultsState m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> StateT DefaultsState m String
resolveVars (Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 String
zs)
  resolveVars (Char
c:String
cs) = (Char
cChar -> ShowS
forall a. a -> [a] -> [a]
:) ShowS
-> StateT DefaultsState m String -> StateT DefaultsState m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> StateT DefaultsState m String
resolveVars String
cs
  lookupEnv' :: String -> StateT DefaultsState m String
  lookupEnv' :: String -> StateT DefaultsState m String
lookupEnv' String
"." = do
    Maybe String
mbCurDefaults <- (DefaultsState -> Maybe String)
-> StateT DefaultsState m (Maybe String)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets DefaultsState -> Maybe String
curDefaults
    StateT DefaultsState m String
-> (String -> StateT DefaultsState m String)
-> Maybe String
-> StateT DefaultsState m String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> StateT DefaultsState m String
forall (m :: * -> *) a. Monad m => a -> m a
return String
"")
          (ShowS
-> StateT DefaultsState m String -> StateT DefaultsState m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ShowS
takeDirectory (StateT DefaultsState m String -> StateT DefaultsState m String)
-> (String -> StateT DefaultsState m String)
-> String
-> StateT DefaultsState m String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO String -> StateT DefaultsState m String
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO String -> StateT DefaultsState m String)
-> (String -> IO String) -> String -> StateT DefaultsState m String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO String
canonicalizePath)
          Maybe String
mbCurDefaults
  lookupEnv' String
"USERDATA" = do
    Maybe String
mbodatadir <- (String -> StateT DefaultsState m String)
-> Maybe String -> StateT DefaultsState m (Maybe String)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM String -> StateT DefaultsState m String
resolveVars Maybe String
oDataDir
    Maybe String
mbdatadir  <- StateT DefaultsState m (Maybe String)
forall (m :: * -> *). PandocMonad m => m (Maybe String)
getUserDataDir
    String
defdatadir <- IO String -> StateT DefaultsState m String
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO String
defaultUserDataDir
    String -> StateT DefaultsState m String
forall (m :: * -> *) a. Monad m => a -> m a
return (String -> StateT DefaultsState m String)
-> String -> StateT DefaultsState m String
forall a b. (a -> b) -> a -> b
$ String -> Maybe String -> String
forall a. a -> Maybe a -> a
fromMaybe String
defdatadir (Maybe String
mbodatadir Maybe String -> Maybe String -> Maybe String
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe String
mbdatadir)
  lookupEnv' String
v = do
    Maybe String
mbval <- (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> String
T.unpack (Maybe Text -> Maybe String)
-> StateT DefaultsState m (Maybe Text)
-> StateT DefaultsState m (Maybe String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> StateT DefaultsState m (Maybe Text)
forall (m :: * -> *). PandocMonad m => Text -> m (Maybe Text)
lookupEnv (String -> Text
T.pack String
v)
    case Maybe String
mbval of
      Maybe String
Nothing -> do
        LogMessage -> StateT DefaultsState m ()
forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
report (LogMessage -> StateT DefaultsState m ())
-> LogMessage -> StateT DefaultsState m ()
forall a b. (a -> b) -> a -> b
$ Text -> LogMessage
EnvironmentVariableUndefined (String -> Text
T.pack String
v)
        String -> StateT DefaultsState m String
forall (m :: * -> *) a. Monad m => a -> m a
return String
forall a. Monoid a => a
mempty
      Just String
x  -> String -> StateT DefaultsState m String
forall (m :: * -> *) a. Monad m => a -> m a
return String
x
  resolveVarsInFilter :: Filter -> StateT DefaultsState m Filter
resolveVarsInFilter (JSONFilter String
fp) =
    String -> Filter
JSONFilter (String -> Filter)
-> StateT DefaultsState m String -> StateT DefaultsState m Filter
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> StateT DefaultsState m String
resolveVars String
fp
  resolveVarsInFilter (LuaFilter String
fp) =
    String -> Filter
LuaFilter (String -> Filter)
-> StateT DefaultsState m String -> StateT DefaultsState m Filter
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> StateT DefaultsState m String
resolveVars String
fp
  resolveVarsInFilter Filter
CiteprocFilter = Filter -> StateT DefaultsState m Filter
forall (m :: * -> *) a. Monad m => a -> m a
return Filter
CiteprocFilter



parseDefaults :: (PandocMonad m, MonadIO m)
              => Value
              -> Maybe FilePath
              -> Parser (Opt -> StateT DefaultsState m Opt)
parseDefaults :: Value -> Maybe String -> Parser (Opt -> StateT DefaultsState m Opt)
parseDefaults Value
n Maybe String
dataDir = Value -> Parser [String]
parseDefsNames Value
n Parser [String]
-> ([String] -> Parser (Opt -> StateT DefaultsState m Opt))
-> Parser (Opt -> StateT DefaultsState m Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[String]
ds -> (Opt -> StateT DefaultsState m Opt)
-> Parser (Opt -> StateT DefaultsState m Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return ((Opt -> StateT DefaultsState m Opt)
 -> Parser (Opt -> StateT DefaultsState m Opt))
-> (Opt -> StateT DefaultsState m Opt)
-> Parser (Opt -> StateT DefaultsState m Opt)
forall a b. (a -> b) -> a -> b
$ \Opt
o -> do
  -- get parent defaults:
  String
defsParent <- (DefaultsState -> String) -> StateT DefaultsState m String
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((DefaultsState -> String) -> StateT DefaultsState m String)
-> (DefaultsState -> String) -> StateT DefaultsState m String
forall a b. (a -> b) -> a -> b
$ String -> Maybe String -> String
forall a. a -> Maybe a -> a
fromMaybe String
"" (Maybe String -> String)
-> (DefaultsState -> Maybe String) -> DefaultsState -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DefaultsState -> Maybe String
curDefaults
  -- get child defaults:
  [String]
defsChildren <- (String -> StateT DefaultsState m String)
-> [String] -> StateT DefaultsState m [String]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Maybe String -> String -> StateT DefaultsState m String
forall (m :: * -> *).
(PandocMonad m, MonadIO m) =>
Maybe String -> String -> m String
fullDefaultsPath Maybe String
dataDir) [String]
ds
  -- expand parent in defaults inheritance graph by children:
  [[String]]
defsGraph <- (DefaultsState -> [[String]]) -> StateT DefaultsState m [[String]]
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets DefaultsState -> [[String]]
inheritanceGraph
  let defsGraphExp :: [[String]]
defsGraphExp = [[String]] -> [String] -> String -> [[String]]
forall a. Ord a => [[a]] -> [a] -> a -> [[a]]
expand [[String]]
defsGraph [String]
defsChildren String
defsParent
  (DefaultsState -> DefaultsState) -> StateT DefaultsState m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((DefaultsState -> DefaultsState) -> StateT DefaultsState m ())
-> (DefaultsState -> DefaultsState) -> StateT DefaultsState m ()
forall a b. (a -> b) -> a -> b
$ \DefaultsState
defsState -> DefaultsState
defsState{ inheritanceGraph :: [[String]]
inheritanceGraph = [[String]]
defsGraphExp }
  -- check for cyclic inheritance:
  if [[String]] -> Bool
forall a. Ord a => [[a]] -> Bool
cyclic [[String]]
defsGraphExp
    then PandocError -> StateT DefaultsState m Opt
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (PandocError -> StateT DefaultsState m Opt)
-> PandocError -> StateT DefaultsState m Opt
forall a b. (a -> b) -> a -> b
$
      Text -> PandocError
PandocSomeError (Text -> PandocError) -> Text -> PandocError
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$
        String
"Error: Circular defaults file reference in " String -> ShowS
forall a. [a] -> [a] -> [a]
++
        String
"'" String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
defsParent String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"'"
    else (Opt -> String -> StateT DefaultsState m Opt)
-> Opt -> [String] -> StateT DefaultsState m Opt
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM Opt -> String -> StateT DefaultsState m Opt
forall (m :: * -> *).
(PandocMonad m, MonadIO m) =>
Opt -> String -> StateT DefaultsState m Opt
applyDefaults Opt
o [String]
defsChildren
  where parseDefsNames :: Value -> Parser [String]
parseDefsNames Value
x = (Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
x Parser [Text] -> ([Text] -> Parser [String]) -> Parser [String]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
xs -> [String] -> Parser [String]
forall (m :: * -> *) a. Monad m => a -> m a
return ([String] -> Parser [String]) -> [String] -> Parser [String]
forall a b. (a -> b) -> a -> b
$ (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
xs)
                       Parser [String] -> Parser [String] -> Parser [String]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
x Parser Text -> (Text -> Parser [String]) -> Parser [String]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x' -> [String] -> Parser [String]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text -> String
unpack Text
x'])

parseOptions :: Monad m
             => [(Text, Value)]
             -> Parser (Opt -> StateT DefaultsState m Opt)
parseOptions :: [(Text, Value)] -> Parser (Opt -> StateT DefaultsState m Opt)
parseOptions [(Text, Value)]
ns = do
  Opt -> Opt
f <- ((Text, Value) -> Parser (Opt -> Opt))
-> [(Text, Value)] -> Parser (Opt -> Opt)
forall (m :: * -> *) a b.
Monad m =>
(a -> m (b -> b)) -> [a] -> m (b -> b)
chain (Text, Value) -> Parser (Opt -> Opt)
doOpt' [(Text, Value)]
ns
  (Opt -> StateT DefaultsState m Opt)
-> Parser (Opt -> StateT DefaultsState m Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return ((Opt -> StateT DefaultsState m Opt)
 -> Parser (Opt -> StateT DefaultsState m Opt))
-> (Opt -> StateT DefaultsState m Opt)
-> Parser (Opt -> StateT DefaultsState m Opt)
forall a b. (a -> b) -> a -> b
$ Opt -> StateT DefaultsState m Opt
forall (m :: * -> *) a. Monad m => a -> m a
return (Opt -> StateT DefaultsState m Opt)
-> (Opt -> Opt) -> Opt -> StateT DefaultsState m Opt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Opt -> Opt
f

chain :: Monad m => (a -> m (b -> b)) -> [a] -> m (b -> b)
chain :: (a -> m (b -> b)) -> [a] -> m (b -> b)
chain a -> m (b -> b)
f = ((b -> b) -> a -> m (b -> b)) -> (b -> b) -> [a] -> m (b -> b)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM (b -> b) -> a -> m (b -> b)
forall a. (a -> b) -> a -> m (a -> b)
g b -> b
forall a. a -> a
id
  where g :: (a -> b) -> a -> m (a -> b)
g a -> b
o a
n = a -> m (b -> b)
f a
n m (b -> b) -> ((b -> b) -> m (a -> b)) -> m (a -> b)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \b -> b
o' -> (a -> b) -> m (a -> b)
forall (m :: * -> *) a. Monad m => a -> m a
return ((a -> b) -> m (a -> b)) -> (a -> b) -> m (a -> b)
forall a b. (a -> b) -> a -> b
$ b -> b
o' (b -> b) -> (a -> b) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
o

doOpt' :: (Text, Value) -> Parser (Opt -> Opt)
doOpt' :: (Text, Value) -> Parser (Opt -> Opt)
doOpt' (Text
k,Value
v) = do
  case Text
k of
    Text
"defaults" -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return Opt -> Opt
forall a. a -> a
id
    Text
_ -> (Text, Value) -> Parser (Opt -> Opt)
doOpt (Text
k,Value
v)

doOpt :: (Text, Value) -> Parser (Opt -> Opt)
doOpt :: (Text, Value) -> Parser (Opt -> Opt)
doOpt (Text
k,Value
v) = do
  case Text
k of
    Text
"tab-stop" ->
      Value -> Parser Int
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Int -> (Int -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Int
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optTabStop :: Int
optTabStop = Int
x })
    Text
"preserve-tabs" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optPreserveTabs :: Bool
optPreserveTabs = Bool
x })
    Text
"standalone" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optStandalone :: Bool
optStandalone = Bool
x })
    Text
"table-of-contents" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optTableOfContents :: Bool
optTableOfContents = Bool
x })
    Text
"toc" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optTableOfContents :: Bool
optTableOfContents = Bool
x })
    Text
"from" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optFrom :: Maybe Text
optFrom = Maybe Text
x })
    Text
"reader" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optFrom :: Maybe Text
optFrom = Maybe Text
x })
    Text
"to" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optTo :: Maybe Text
optTo = Maybe Text
x })
    Text
"writer" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optTo :: Maybe Text
optTo = Maybe Text
x })
    Text
"shift-heading-level-by" ->
      Value -> Parser Int
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Int -> (Int -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Int
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optShiftHeadingLevelBy :: Int
optShiftHeadingLevelBy = Int
x })
    Text
"template" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optTemplate :: Maybe String
optTemplate = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"variables" ->
      Value -> Parser (Context Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Context Text)
-> (Context Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Context Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optVariables :: Context Text
optVariables =
                                               Context Text
x Context Text -> Context Text -> Context Text
forall a. Semigroup a => a -> a -> a
<> Opt -> Context Text
optVariables Opt
o })
      -- Note: x comes first because <> for Context is left-biased union
      -- and we want to favor later default files. See #5988.
    Text
"metadata" ->
      Value -> Parser Meta
yamlToMeta Value
v Parser Meta -> (Meta -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Meta
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optMetadata :: Meta
optMetadata = Opt -> Meta
optMetadata Opt
o Meta -> Meta -> Meta
forall a. Semigroup a => a -> a -> a
<> Meta
x })
    Text
"metadata-files" ->
      Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x ->
                        (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optMetadataFiles :: [String]
optMetadataFiles =
                                           Opt -> [String]
optMetadataFiles Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                           (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x })
    Text
"metadata-file" -> -- allow either a list or a single value
      (Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optMetadataFiles :: [String]
optMetadataFiles =
                                                Opt -> [String]
optMetadataFiles Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                                (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Text -> (Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x ->
                        (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optMetadataFiles :: [String]
optMetadataFiles =
                                           Opt -> [String]
optMetadataFiles Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>[Text -> String
unpack Text
x] }))
    Text
"output-file" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optOutputFile :: Maybe String
optOutputFile = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"input-files" ->
      Value -> Parser (Maybe [Text])
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe [Text])
-> (Maybe [Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe [Text]
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optInputFiles :: Maybe [String]
optInputFiles =
                                              Opt -> Maybe [String]
optInputFiles Opt
o Maybe [String] -> Maybe [String] -> Maybe [String]
forall a. Semigroup a => a -> a -> a
<>
                                                ((Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack ([Text] -> [String]) -> Maybe [Text] -> Maybe [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe [Text]
x) })
    Text
"input-file" -> -- allow either a list or a single value
      (Value -> Parser (Maybe [Text])
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe [Text])
-> (Maybe [Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe [Text]
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optInputFiles :: Maybe [String]
optInputFiles =
                                                Opt -> Maybe [String]
optInputFiles Opt
o Maybe [String] -> Maybe [String] -> Maybe [String]
forall a. Semigroup a => a -> a -> a
<>
                                                  ((Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack ([Text] -> [String]) -> Maybe [Text] -> Maybe [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe [Text]
x) }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optInputFiles :: Maybe [String]
optInputFiles =
                                                Opt -> Maybe [String]
optInputFiles Opt
o Maybe [String] -> Maybe [String] -> Maybe [String]
forall a. Semigroup a => a -> a -> a
<>
                                                ((\Text
z -> [Text -> String
unpack Text
z]) (Text -> [String]) -> Maybe Text -> Maybe [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x)
                                            }))
    Text
"number-sections" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optNumberSections :: Bool
optNumberSections = Bool
x })
    Text
"number-offset" ->
      Value -> Parser [Int]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Int]
-> ([Int] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Int]
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optNumberOffset :: [Int]
optNumberOffset = [Int]
x })
    Text
"section-divs" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optSectionDivs :: Bool
optSectionDivs = Bool
x })
    Text
"incremental" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optIncremental :: Bool
optIncremental = Bool
x })
    Text
"self-contained" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optSelfContained :: Bool
optSelfContained = Bool
x })
    Text
"html-q-tags" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optHtmlQTags :: Bool
optHtmlQTags = Bool
x })
    Text
"highlight-style" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optHighlightStyle :: Maybe Text
optHighlightStyle = Maybe Text
x })
    Text
"syntax-definition" ->
      (Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x ->
                (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optSyntaxDefinitions :: [String]
optSyntaxDefinitions =
                                   Opt -> [String]
optSyntaxDefinitions Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Text -> (Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optSyntaxDefinitions :: [String]
optSyntaxDefinitions =
                                 Opt -> [String]
optSyntaxDefinitions Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [Text -> String
unpack Text
x] }))
    Text
"syntax-definitions" ->
      Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optSyntaxDefinitions :: [String]
optSyntaxDefinitions =
                                Opt -> [String]
optSyntaxDefinitions Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x })
    Text
"top-level-division" ->
      Value -> Parser TopLevelDivision
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser TopLevelDivision
-> (TopLevelDivision -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \TopLevelDivision
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optTopLevelDivision :: TopLevelDivision
optTopLevelDivision = TopLevelDivision
x })
    Text
"html-math-method" ->
      Value -> Parser HTMLMathMethod
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser HTMLMathMethod
-> (HTMLMathMethod -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \HTMLMathMethod
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optHTMLMathMethod :: HTMLMathMethod
optHTMLMathMethod = HTMLMathMethod
x })
    Text
"abbreviations" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optAbbreviations :: Maybe String
optAbbreviations = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"reference-doc" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optReferenceDoc :: Maybe String
optReferenceDoc = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"epub-subdirectory" ->
      Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Text -> (Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optEpubSubdirectory :: String
optEpubSubdirectory = Text -> String
unpack Text
x })
    Text
"epub-metadata" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optEpubMetadata :: Maybe String
optEpubMetadata = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"epub-fonts" ->
      Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optEpubFonts :: [String]
optEpubFonts = Opt -> [String]
optEpubFonts Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                               (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x })
    Text
"epub-chapter-level" ->
      Value -> Parser Int
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Int -> (Int -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Int
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optEpubChapterLevel :: Int
optEpubChapterLevel = Int
x })
    Text
"epub-cover-image" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optEpubCoverImage :: Maybe String
optEpubCoverImage = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"toc-depth" ->
      Value -> Parser Int
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Int -> (Int -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Int
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optTOCDepth :: Int
optTOCDepth = Int
x })
    Text
"dump-args" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optDumpArgs :: Bool
optDumpArgs = Bool
x })
    Text
"ignore-args" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optIgnoreArgs :: Bool
optIgnoreArgs = Bool
x })
    Text
"verbosity" ->
      Value -> Parser Verbosity
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Verbosity
-> (Verbosity -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Verbosity
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optVerbosity :: Verbosity
optVerbosity = Verbosity
x })
    Text
"trace" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optTrace :: Bool
optTrace = Bool
x })
    Text
"log-file" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optLogFile :: Maybe String
optLogFile = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"fail-if-warnings" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optFailIfWarnings :: Bool
optFailIfWarnings = Bool
x })
    Text
"reference-links" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optReferenceLinks :: Bool
optReferenceLinks = Bool
x })
    Text
"reference-location" ->
      Value -> Parser ReferenceLocation
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser ReferenceLocation
-> (ReferenceLocation -> Parser (Opt -> Opt))
-> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ReferenceLocation
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optReferenceLocation :: ReferenceLocation
optReferenceLocation = ReferenceLocation
x })
    Text
"dpi" ->
      Value -> Parser Int
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Int -> (Int -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Int
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optDpi :: Int
optDpi = Int
x })
    Text
"wrap" ->
      Value -> Parser WrapOption
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser WrapOption
-> (WrapOption -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \WrapOption
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optWrap :: WrapOption
optWrap = WrapOption
x })
    Text
"columns" ->
      Value -> Parser Int
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Int -> (Int -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Int
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optColumns :: Int
optColumns = Int
x })
    Text
"filters" ->
      Value -> Parser [Filter]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Filter]
-> ([Filter] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Filter]
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optFilters :: [Filter]
optFilters = Opt -> [Filter]
optFilters Opt
o [Filter] -> [Filter] -> [Filter]
forall a. Semigroup a => a -> a -> a
<> [Filter]
x })
    Text
"citeproc" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x ->
        if Bool
x
           then (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optFilters :: [Filter]
optFilters = Filter
CiteprocFilter Filter -> [Filter] -> [Filter]
forall a. a -> [a] -> [a]
: Opt -> [Filter]
optFilters Opt
o })
           else (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return Opt -> Opt
forall a. a -> a
id
    Text
"email-obfuscation" ->
      Value -> Parser ObfuscationMethod
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser ObfuscationMethod
-> (ObfuscationMethod -> Parser (Opt -> Opt))
-> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ObfuscationMethod
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optEmailObfuscation :: ObfuscationMethod
optEmailObfuscation = ObfuscationMethod
x })
    Text
"identifier-prefix" ->
      Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Text -> (Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optIdentifierPrefix :: Text
optIdentifierPrefix = Text
x })
    Text
"strip-empty-paragraphs" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optStripEmptyParagraphs :: Bool
optStripEmptyParagraphs = Bool
x })
    Text
"indented-code-classes" ->
      Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optIndentedCodeClasses :: [Text]
optIndentedCodeClasses = [Text]
x })
    Text
"data-dir" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optDataDir :: Maybe String
optDataDir = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"cite-method" ->
      Value -> Parser CiteMethod
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser CiteMethod
-> (CiteMethod -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \CiteMethod
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optCiteMethod :: CiteMethod
optCiteMethod = CiteMethod
x })
    Text
"listings" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optListings :: Bool
optListings = Bool
x })
    Text
"pdf-engine" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optPdfEngine :: Maybe String
optPdfEngine = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"pdf-engine-opts" ->
      Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optPdfEngineOpts :: [String]
optPdfEngineOpts = (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x })
    Text
"pdf-engine-opt" ->
      (Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optPdfEngineOpts :: [String]
optPdfEngineOpts = (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Text -> (Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optPdfEngineOpts :: [String]
optPdfEngineOpts = [Text -> String
unpack Text
x] }))
    Text
"slide-level" ->
      Value -> Parser (Maybe Int)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Int)
-> (Maybe Int -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Int
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optSlideLevel :: Maybe Int
optSlideLevel = Maybe Int
x })
    Text
"atx-headers" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optSetextHeaders :: Bool
optSetextHeaders = Bool -> Bool
not Bool
x })
    Text
"markdown-headings" ->
      Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Text -> (Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o ->
        case Text -> Text
T.toLower Text
x of
          Text
"atx"    -> Opt
o{ optSetextHeaders :: Bool
optSetextHeaders = Bool
False }
          Text
"setext" -> Opt
o{ optSetextHeaders :: Bool
optSetextHeaders = Bool
True }
          Text
_        -> Opt
o)
    Text
"ascii" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optAscii :: Bool
optAscii = Bool
x })
    Text
"default-image-extension" ->
      Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Text -> (Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optDefaultImageExtension :: Text
optDefaultImageExtension = Text
x })
    Text
"extract-media" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optExtractMedia :: Maybe String
optExtractMedia = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"track-changes" ->
      Value -> Parser TrackChanges
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser TrackChanges
-> (TrackChanges -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \TrackChanges
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optTrackChanges :: TrackChanges
optTrackChanges = TrackChanges
x })
    Text
"file-scope" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optFileScope :: Bool
optFileScope = Bool
x })
    Text
"title-prefix" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optTitlePrefix :: Maybe Text
optTitlePrefix = Maybe Text
x,
                                             optStandalone :: Bool
optStandalone = Bool
True })
    Text
"css" ->
      (Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optCss :: [String]
optCss = Opt -> [String]
optCss Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                                 (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Text -> (Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optCss :: [String]
optCss = Opt -> [String]
optCss Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                                [Text -> String
unpack Text
x] }))
    Text
"bibliography" ->
      (Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o ->
                               Opt
o{ optBibliography :: [String]
optBibliography = Opt -> [String]
optBibliography Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                                      (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Text -> (Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o ->
                               Opt
o{ optBibliography :: [String]
optBibliography = Opt -> [String]
optBibliography Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                                       [Text -> String
unpack Text
x] }))
    Text
"csl" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optCSL :: Maybe String
optCSL = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"citation-abbreviations" ->
      Value -> Parser (Maybe Text)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser (Maybe Text)
-> (Maybe Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Text
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optCitationAbbreviations :: Maybe String
optCitationAbbreviations =
                                                  Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"ipynb-output" ->
      Value -> Parser IpynbOutput
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser IpynbOutput
-> (IpynbOutput -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \IpynbOutput
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optIpynbOutput :: IpynbOutput
optIpynbOutput = IpynbOutput
x })
    Text
"include-before-body" ->
      (Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optIncludeBeforeBody :: [String]
optIncludeBeforeBody =
                                Opt -> [String]
optIncludeBeforeBody Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Text -> (Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optIncludeBeforeBody :: [String]
optIncludeBeforeBody =
                                Opt -> [String]
optIncludeBeforeBody Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [Text -> String
unpack Text
x] }))
    Text
"include-after-body" ->
      (Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optIncludeAfterBody :: [String]
optIncludeAfterBody =
                                Opt -> [String]
optIncludeAfterBody Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Text -> (Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optIncludeAfterBody :: [String]
optIncludeAfterBody =
                                Opt -> [String]
optIncludeAfterBody Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [Text -> String
unpack Text
x] }))
    Text
"include-in-header" ->
      (Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optIncludeInHeader :: [String]
optIncludeInHeader =
                                Opt -> [String]
optIncludeInHeader Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Value -> Parser Text
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Text -> (Text -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optIncludeInHeader :: [String]
optIncludeInHeader =
                                Opt -> [String]
optIncludeInHeader Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [Text -> String
unpack Text
x] }))
    Text
"resource-path" ->
      Value -> Parser [Text]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [Text]
-> ([Text] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optResourcePath :: [String]
optResourcePath = (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                 Opt -> [String]
optResourcePath Opt
o })
    Text
"request-headers" ->
      Value -> Parser [(Text, Text)]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser [(Text, Text)]
-> ([(Text, Text)] -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[(Text, Text)]
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optRequestHeaders :: [(Text, Text)]
optRequestHeaders = [(Text, Text)]
x })
    Text
"no-check-certificate" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x ->
             (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optNoCheckCertificate :: Bool
optNoCheckCertificate = Bool
x })
    Text
"eol" ->
      Value -> Parser LineEnding
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser LineEnding
-> (LineEnding -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \LineEnding
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o{ optEol :: LineEnding
optEol = LineEnding
x })
    Text
"strip-comments" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o  { optStripComments :: Bool
optStripComments = Bool
x })
    Text
"sandbox" ->
      Value -> Parser Bool
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v Parser Bool -> (Bool -> Parser (Opt -> Opt)) -> Parser (Opt -> Opt)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
x -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return (\Opt
o -> Opt
o  { optSandbox :: Bool
optSandbox = Bool
x })
    Text
_ -> String -> Parser (Opt -> Opt)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser (Opt -> Opt)) -> String -> Parser (Opt -> Opt)
forall a b. (a -> b) -> a -> b
$ String
"Unknown option " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
forall a. Show a => a -> String
show Text
k

-- | Defaults for command-line options.
defaultOpts :: Opt
defaultOpts :: Opt
defaultOpts = Opt :: Int
-> Bool
-> Bool
-> Maybe Text
-> Maybe Text
-> Bool
-> Int
-> Maybe String
-> Context Text
-> Meta
-> [String]
-> Maybe String
-> Maybe [String]
-> Bool
-> [Int]
-> Bool
-> Bool
-> Bool
-> Bool
-> Maybe Text
-> [String]
-> TopLevelDivision
-> HTMLMathMethod
-> Maybe String
-> Maybe String
-> String
-> Maybe String
-> [String]
-> Int
-> Maybe String
-> Int
-> Bool
-> Bool
-> Verbosity
-> Bool
-> Maybe String
-> Bool
-> Bool
-> ReferenceLocation
-> Int
-> WrapOption
-> Int
-> [Filter]
-> ObfuscationMethod
-> Text
-> Bool
-> [Text]
-> Maybe String
-> CiteMethod
-> Bool
-> Maybe String
-> [String]
-> Maybe Int
-> Bool
-> Bool
-> Text
-> Maybe String
-> TrackChanges
-> Bool
-> Maybe Text
-> [String]
-> IpynbOutput
-> [String]
-> [String]
-> [String]
-> [String]
-> [(Text, Text)]
-> Bool
-> LineEnding
-> Bool
-> Maybe String
-> [String]
-> Maybe String
-> Bool
-> Opt
Opt
    { optTabStop :: Int
optTabStop               = Int
4
    , optPreserveTabs :: Bool
optPreserveTabs          = Bool
False
    , optStandalone :: Bool
optStandalone            = Bool
False
    , optFrom :: Maybe Text
optFrom                  = Maybe Text
forall a. Maybe a
Nothing
    , optTo :: Maybe Text
optTo                    = Maybe Text
forall a. Maybe a
Nothing
    , optTableOfContents :: Bool
optTableOfContents       = Bool
False
    , optShiftHeadingLevelBy :: Int
optShiftHeadingLevelBy   = Int
0
    , optTemplate :: Maybe String
optTemplate              = Maybe String
forall a. Maybe a
Nothing
    , optVariables :: Context Text
optVariables             = Context Text
forall a. Monoid a => a
mempty
    , optMetadata :: Meta
optMetadata              = Meta
forall a. Monoid a => a
mempty
    , optMetadataFiles :: [String]
optMetadataFiles         = []
    , optOutputFile :: Maybe String
optOutputFile            = Maybe String
forall a. Maybe a
Nothing
    , optInputFiles :: Maybe [String]
optInputFiles            = Maybe [String]
forall a. Maybe a
Nothing
    , optNumberSections :: Bool
optNumberSections        = Bool
False
    , optNumberOffset :: [Int]
optNumberOffset          = [Int
0,Int
0,Int
0,Int
0,Int
0,Int
0]
    , optSectionDivs :: Bool
optSectionDivs           = Bool
False
    , optIncremental :: Bool
optIncremental           = Bool
False
    , optSelfContained :: Bool
optSelfContained         = Bool
False
    , optHtmlQTags :: Bool
optHtmlQTags             = Bool
False
    , optHighlightStyle :: Maybe Text
optHighlightStyle        = Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"pygments"
    , optSyntaxDefinitions :: [String]
optSyntaxDefinitions     = []
    , optTopLevelDivision :: TopLevelDivision
optTopLevelDivision      = TopLevelDivision
TopLevelDefault
    , optHTMLMathMethod :: HTMLMathMethod
optHTMLMathMethod        = HTMLMathMethod
PlainMath
    , optAbbreviations :: Maybe String
optAbbreviations         = Maybe String
forall a. Maybe a
Nothing
    , optReferenceDoc :: Maybe String
optReferenceDoc          = Maybe String
forall a. Maybe a
Nothing
    , optEpubSubdirectory :: String
optEpubSubdirectory      = String
"EPUB"
    , optEpubMetadata :: Maybe String
optEpubMetadata          = Maybe String
forall a. Maybe a
Nothing
    , optEpubFonts :: [String]
optEpubFonts             = []
    , optEpubChapterLevel :: Int
optEpubChapterLevel      = Int
1
    , optEpubCoverImage :: Maybe String
optEpubCoverImage        = Maybe String
forall a. Maybe a
Nothing
    , optTOCDepth :: Int
optTOCDepth              = Int
3
    , optDumpArgs :: Bool
optDumpArgs              = Bool
False
    , optIgnoreArgs :: Bool
optIgnoreArgs            = Bool
False
    , optVerbosity :: Verbosity
optVerbosity             = Verbosity
WARNING
    , optTrace :: Bool
optTrace                 = Bool
False
    , optLogFile :: Maybe String
optLogFile               = Maybe String
forall a. Maybe a
Nothing
    , optFailIfWarnings :: Bool
optFailIfWarnings        = Bool
False
    , optReferenceLinks :: Bool
optReferenceLinks        = Bool
False
    , optReferenceLocation :: ReferenceLocation
optReferenceLocation     = ReferenceLocation
EndOfDocument
    , optDpi :: Int
optDpi                   = Int
96
    , optWrap :: WrapOption
optWrap                  = WrapOption
WrapAuto
    , optColumns :: Int
optColumns               = Int
72
    , optFilters :: [Filter]
optFilters               = []
    , optEmailObfuscation :: ObfuscationMethod
optEmailObfuscation      = ObfuscationMethod
NoObfuscation
    , optIdentifierPrefix :: Text
optIdentifierPrefix      = Text
""
    , optStripEmptyParagraphs :: Bool
optStripEmptyParagraphs  = Bool
False
    , optIndentedCodeClasses :: [Text]
optIndentedCodeClasses   = []
    , optDataDir :: Maybe String
optDataDir               = Maybe String
forall a. Maybe a
Nothing
    , optCiteMethod :: CiteMethod
optCiteMethod            = CiteMethod
Citeproc
    , optListings :: Bool
optListings              = Bool
False
    , optPdfEngine :: Maybe String
optPdfEngine             = Maybe String
forall a. Maybe a
Nothing
    , optPdfEngineOpts :: [String]
optPdfEngineOpts         = []
    , optSlideLevel :: Maybe Int
optSlideLevel            = Maybe Int
forall a. Maybe a
Nothing
    , optSetextHeaders :: Bool
optSetextHeaders         = Bool
False
    , optAscii :: Bool
optAscii                 = Bool
False
    , optDefaultImageExtension :: Text
optDefaultImageExtension = Text
""
    , optExtractMedia :: Maybe String
optExtractMedia          = Maybe String
forall a. Maybe a
Nothing
    , optTrackChanges :: TrackChanges
optTrackChanges          = TrackChanges
AcceptChanges
    , optFileScope :: Bool
optFileScope             = Bool
False
    , optTitlePrefix :: Maybe Text
optTitlePrefix           = Maybe Text
forall a. Maybe a
Nothing
    , optCss :: [String]
optCss                   = []
    , optIpynbOutput :: IpynbOutput
optIpynbOutput           = IpynbOutput
IpynbOutputBest
    , optIncludeBeforeBody :: [String]
optIncludeBeforeBody     = []
    , optIncludeAfterBody :: [String]
optIncludeAfterBody      = []
    , optIncludeInHeader :: [String]
optIncludeInHeader       = []
    , optResourcePath :: [String]
optResourcePath          = [String
"."]
    , optRequestHeaders :: [(Text, Text)]
optRequestHeaders        = []
    , optNoCheckCertificate :: Bool
optNoCheckCertificate    = Bool
False
    , optEol :: LineEnding
optEol                   = LineEnding
Native
    , optStripComments :: Bool
optStripComments         = Bool
False
    , optCSL :: Maybe String
optCSL                   = Maybe String
forall a. Maybe a
Nothing
    , optBibliography :: [String]
optBibliography          = []
    , optCitationAbbreviations :: Maybe String
optCitationAbbreviations = Maybe String
forall a. Maybe a
Nothing
    , optSandbox :: Bool
optSandbox               = Bool
False
    }

yamlToMeta :: Value -> Parser Meta
yamlToMeta :: Value -> Parser Meta
yamlToMeta (Object Object
o) =
  (PandocError -> Parser Meta)
-> (Meta -> Parser Meta) -> Either PandocError Meta -> Parser Meta
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (String -> Parser Meta
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser Meta)
-> (PandocError -> String) -> PandocError -> Parser Meta
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PandocError -> String
forall a. Show a => a -> String
show) Meta -> Parser Meta
forall (m :: * -> *) a. Monad m => a -> m a
return (Either PandocError Meta -> Parser Meta)
-> Either PandocError Meta -> Parser Meta
forall a b. (a -> b) -> a -> b
$ ParserT
  Sources
  ParserState
  PandocPure
  (Future ParserState (Map Text MetaValue))
-> Either PandocError Meta
forall s.
Default s =>
ParserT
  Sources ParserState PandocPure (Future s (Map Text MetaValue))
-> Either PandocError Meta
runEverything (ParserT
  Sources ParserState PandocPure (Future ParserState MetaValue)
-> Object
-> ParserT
     Sources
     ParserState
     PandocPure
     (Future ParserState (Map Text MetaValue))
forall (m :: * -> *) st.
(PandocMonad m, HasLastStrPosition st) =>
ParserT Sources st m (Future st MetaValue)
-> Object -> ParserT Sources st m (Future st (Map Text MetaValue))
yamlMap ParserT
  Sources ParserState PandocPure (Future ParserState MetaValue)
forall st.
ParsecT Sources st PandocPure (Future ParserState MetaValue)
pMetaString Object
o)
 where
  pMetaString :: ParsecT Sources st PandocPure (Future ParserState MetaValue)
pMetaString = MetaValue -> Future ParserState MetaValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MetaValue -> Future ParserState MetaValue)
-> (Text -> MetaValue) -> Text -> Future ParserState MetaValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> MetaValue
MetaString (Text -> Future ParserState MetaValue)
-> ParsecT Sources st PandocPure Text
-> ParsecT Sources st PandocPure (Future ParserState MetaValue)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserT Sources st PandocPure Char
-> ParsecT Sources st PandocPure Text
forall s (m :: * -> *) t st.
Stream s m t =>
ParserT s st m Char -> ParserT s st m Text
P.manyChar ParserT Sources st PandocPure Char
forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
ParsecT s u m Char
P.anyChar
  runEverything :: ParserT
  Sources ParserState PandocPure (Future s (Map Text MetaValue))
-> Either PandocError Meta
runEverything ParserT
  Sources ParserState PandocPure (Future s (Map Text MetaValue))
p =
      PandocPure (Either PandocError (Future s (Map Text MetaValue)))
-> Either
     PandocError (Either PandocError (Future s (Map Text MetaValue)))
forall a. PandocPure a -> Either PandocError a
runPure (ParserT
  Sources ParserState PandocPure (Future s (Map Text MetaValue))
-> ParserState
-> Text
-> PandocPure (Either PandocError (Future s (Map Text MetaValue)))
forall (m :: * -> *) t st a.
(Monad m, ToSources t) =>
ParserT Sources st m a -> st -> t -> m (Either PandocError a)
P.readWithM ParserT
  Sources ParserState PandocPure (Future s (Map Text MetaValue))
p (ParserState
forall a. Default a => a
def :: P.ParserState) (Text
"" :: Text))
      Either
  PandocError (Either PandocError (Future s (Map Text MetaValue)))
-> (Either PandocError (Future s (Map Text MetaValue))
    -> Either PandocError Meta)
-> Either PandocError Meta
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Future s (Map Text MetaValue) -> Meta)
-> Either PandocError (Future s (Map Text MetaValue))
-> Either PandocError Meta
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Map Text MetaValue -> Meta
Meta (Map Text MetaValue -> Meta)
-> (Future s (Map Text MetaValue) -> Map Text MetaValue)
-> Future s (Map Text MetaValue)
-> Meta
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Future s (Map Text MetaValue) -> s -> Map Text MetaValue)
-> s -> Future s (Map Text MetaValue) -> Map Text MetaValue
forall a b c. (a -> b -> c) -> b -> a -> c
flip Future s (Map Text MetaValue) -> s -> Map Text MetaValue
forall s a. Future s a -> s -> a
P.runF s
forall a. Default a => a
def)
yamlToMeta Value
_ = Meta -> Parser Meta
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
forall a. Monoid a => a
mempty

-- | Apply defaults from --defaults file.
applyDefaults :: (PandocMonad m, MonadIO m)
              => Opt
              -> FilePath
              -> StateT DefaultsState m Opt
applyDefaults :: Opt -> String -> StateT DefaultsState m Opt
applyDefaults Opt
opt String
file = do
  Verbosity -> StateT DefaultsState m ()
forall (m :: * -> *). PandocMonad m => Verbosity -> m ()
setVerbosity (Verbosity -> StateT DefaultsState m ())
-> Verbosity -> StateT DefaultsState m ()
forall a b. (a -> b) -> a -> b
$ Opt -> Verbosity
optVerbosity Opt
opt
  (DefaultsState -> DefaultsState) -> StateT DefaultsState m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((DefaultsState -> DefaultsState) -> StateT DefaultsState m ())
-> (DefaultsState -> DefaultsState) -> StateT DefaultsState m ()
forall a b. (a -> b) -> a -> b
$ \DefaultsState
defsState -> DefaultsState
defsState{ curDefaults :: Maybe String
curDefaults = String -> Maybe String
forall a. a -> Maybe a
Just String
file }
  ByteString
inp <- String -> StateT DefaultsState m ByteString
forall (m :: * -> *). PandocMonad m => String -> m ByteString
readFileStrict String
file
  case ByteString
-> Either ParseException (Opt -> StateT DefaultsState m Opt)
forall a. FromJSON a => ByteString -> Either ParseException a
decodeEither' ByteString
inp of
      Right Opt -> StateT DefaultsState m Opt
f -> Opt -> StateT DefaultsState m Opt
f Opt
opt
      Left ParseException
err'  -> PandocError -> StateT DefaultsState m Opt
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (PandocError -> StateT DefaultsState m Opt)
-> PandocError -> StateT DefaultsState m Opt
forall a b. (a -> b) -> a -> b
$
         Text -> PandocError
PandocParseError
             (Text -> PandocError) -> Text -> PandocError
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ ParseException -> String
Data.Yaml.prettyPrintParseException ParseException
err'

fullDefaultsPath :: (PandocMonad m, MonadIO m)
                 => Maybe FilePath
                 -> FilePath
                 -> m FilePath
fullDefaultsPath :: Maybe String -> String -> m String
fullDefaultsPath Maybe String
dataDir String
file = do
  let fp :: String
fp = if String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (ShowS
takeExtension String
file)
              then String -> ShowS
addExtension String
file String
"yaml"
              else String
file
  String
defaultDataDir <- IO String -> m String
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO String
defaultUserDataDir
  let defaultFp :: String
defaultFp = String -> Maybe String -> String
forall a. a -> Maybe a -> a
fromMaybe String
defaultDataDir Maybe String
dataDir String -> ShowS
</> String
"defaults" String -> ShowS
</> String
fp
  String -> Maybe String -> String
forall a. a -> Maybe a -> a
fromMaybe String
fp (Maybe String -> String) -> m (Maybe String) -> m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (String -> m Bool) -> [String] -> m (Maybe String)
forall (m :: * -> *) (t :: * -> *) a.
(Monad m, Foldable t) =>
(a -> m Bool) -> t a -> m (Maybe a)
findM String -> m Bool
forall (m :: * -> *). PandocMonad m => String -> m Bool
fileExists [String
fp, String
defaultFp]

-- | In a list of lists, append another list in front of every list which
-- starts with specific element.
expand :: Ord a => [[a]] -> [a] -> a -> [[a]]
expand :: [[a]] -> [a] -> a -> [[a]]
expand [] [a]
ns a
n = (a -> [a]) -> [a] -> [[a]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\a
x -> a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a
n]) [a]
ns
expand [[a]]
ps [a]
ns a
n = ([a] -> [[a]]) -> [[a]] -> [[a]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (a -> [a] -> [a] -> [[a]]
forall a. Eq a => a -> [a] -> [a] -> [[a]]
ext a
n [a]
ns) [[a]]
ps
  where
    ext :: a -> [a] -> [a] -> [[a]]
ext a
x [a]
xs [a]
p = case [a]
p of
      (a
l : [a]
_) | a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
l -> (a -> [a]) -> [a] -> [[a]]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
p) [a]
xs
      [a]
_ -> [[a]
p]

cyclic :: Ord a => [[a]] -> Bool
cyclic :: [[a]] -> Bool
cyclic = ([a] -> Bool) -> [[a]] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any [a] -> Bool
forall a. Ord a => [a] -> Bool
hasDuplicate
  where
    hasDuplicate :: [a] -> Bool
hasDuplicate [a]
xs = [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length ([a] -> [a]
forall a. Ord a => [a] -> [a]
ordNub [a]
xs) Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
xs