{-# 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 (isLower, 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 (readFileLazy, fileExists, setVerbosity, report,
                          PandocMonad(lookupEnv), getUserDataDir)
import Text.Pandoc.Error (PandocError (PandocParseError, PandocSomeError))
import Text.Pandoc.Shared (camelCaseStrToHyphenated, 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(..))
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 -> FilePath
(Int -> LineEnding -> ShowS)
-> (LineEnding -> FilePath)
-> ([LineEnding] -> ShowS)
-> Show LineEnding
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [LineEnding] -> ShowS
$cshowList :: [LineEnding] -> ShowS
show :: LineEnding -> FilePath
$cshow :: LineEnding -> FilePath
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)

instance FromYAML LineEnding where
  parseYAML :: Node Pos -> Parser LineEnding
parseYAML = FilePath
-> (Text -> Parser LineEnding) -> Node Pos -> Parser LineEnding
forall a. FilePath -> (Text -> Parser a) -> Node Pos -> Parser a
withStr FilePath
"LineEnding" ((Text -> Parser LineEnding) -> Node Pos -> Parser LineEnding)
-> (Text -> Parser LineEnding) -> Node Pos -> Parser LineEnding
forall a b. (a -> b) -> a -> b
$ \Text
t ->
    case Text -> Text
T.toLower Text
t of
      Text
"lf"     -> LineEnding -> Parser LineEnding
forall (m :: * -> *) a. Monad m => a -> m a
return LineEnding
LF
      Text
"crlf"   -> LineEnding -> Parser LineEnding
forall (m :: * -> *) a. Monad m => a -> m a
return LineEnding
CRLF
      Text
"native" -> LineEnding -> Parser LineEnding
forall (m :: * -> *) a. Monad m => a -> m a
return LineEnding
Native
      Text
_        -> FilePath -> Parser LineEnding
forall (m :: * -> *) a. MonadFail m => FilePath -> m a
fail (FilePath -> Parser LineEnding) -> FilePath -> Parser LineEnding
forall a b. (a -> b) -> a -> b
$ FilePath
"Unknown line ending type " FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> FilePath
forall a. Show a => a -> FilePath
show Text
t

-- | How to handle output blocks in ipynb.
data IpynbOutput =
    IpynbOutputAll
  | IpynbOutputNone
  | IpynbOutputBest
  deriving (Int -> IpynbOutput -> ShowS
[IpynbOutput] -> ShowS
IpynbOutput -> FilePath
(Int -> IpynbOutput -> ShowS)
-> (IpynbOutput -> FilePath)
-> ([IpynbOutput] -> ShowS)
-> Show IpynbOutput
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [IpynbOutput] -> ShowS
$cshowList :: [IpynbOutput] -> ShowS
show :: IpynbOutput -> FilePath
$cshow :: IpynbOutput -> FilePath
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)

instance FromYAML IpynbOutput where
  parseYAML :: Node Pos -> Parser IpynbOutput
parseYAML = FilePath
-> (Text -> Parser IpynbOutput) -> Node Pos -> Parser IpynbOutput
forall a. FilePath -> (Text -> Parser a) -> Node Pos -> Parser a
withStr FilePath
"LineEnding" ((Text -> Parser IpynbOutput) -> Node Pos -> Parser IpynbOutput)
-> (Text -> Parser IpynbOutput) -> Node Pos -> Parser IpynbOutput
forall a b. (a -> b) -> a -> b
$ \Text
t ->
    case Text
t of
      Text
"none"  -> IpynbOutput -> Parser IpynbOutput
forall (m :: * -> *) a. Monad m => a -> m a
return IpynbOutput
IpynbOutputNone
      Text
"all"   -> IpynbOutput -> Parser IpynbOutput
forall (m :: * -> *) a. Monad m => a -> m a
return IpynbOutput
IpynbOutputAll
      Text
"best"  -> IpynbOutput -> Parser IpynbOutput
forall (m :: * -> *) a. Monad m => a -> m a
return IpynbOutput
IpynbOutputBest
      Text
_       -> FilePath -> Parser IpynbOutput
forall (m :: * -> *) a. MonadFail m => FilePath -> m a
fail (FilePath -> Parser IpynbOutput) -> FilePath -> Parser IpynbOutput
forall a b. (a -> b) -> a -> b
$ FilePath
"Unknown ipynb output type " FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> FilePath
forall a. Show a => a -> FilePath
show Text
t

-- | 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 FilePath
optTemplate              :: Maybe FilePath  -- ^ Custom template
    , Opt -> Context Text
optVariables             :: Context Text    -- ^ Template variables to set
    , Opt -> Meta
optMetadata              :: Meta -- ^ Metadata fields to set
    , Opt -> [FilePath]
optMetadataFiles         :: [FilePath]  -- ^ Name of YAML metadata files
    , Opt -> Maybe FilePath
optOutputFile            :: Maybe FilePath  -- ^ Name of output file
    , Opt -> Maybe [FilePath]
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 -> [FilePath]
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 FilePath
optAbbreviations         :: Maybe FilePath -- ^ Path to abbrevs file
    , Opt -> Maybe FilePath
optReferenceDoc          :: Maybe FilePath -- ^ Path of reference doc
    , Opt -> FilePath
optEpubSubdirectory      :: String -- ^ EPUB subdir in OCF container
    , Opt -> Maybe FilePath
optEpubMetadata          :: Maybe FilePath   -- ^ EPUB metadata
    , Opt -> [FilePath]
optEpubFonts             :: [FilePath] -- ^ EPUB fonts to embed
    , Opt -> Int
optEpubChapterLevel      :: Int     -- ^ Header level at which to split chapters
    , Opt -> Maybe FilePath
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 FilePath
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 FilePath
optDataDir               :: Maybe FilePath
    , Opt -> CiteMethod
optCiteMethod            :: CiteMethod -- ^ Method to output cites
    , Opt -> Bool
optListings              :: Bool       -- ^ Use listings package for code blocks
    , Opt -> Maybe FilePath
optPdfEngine             :: Maybe String -- ^ Program to use for latex/html -> pdf
    , Opt -> [FilePath]
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 FilePath
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 -> [FilePath]
optCss                   :: [FilePath]       -- ^ CSS files to link to
    , Opt -> IpynbOutput
optIpynbOutput           :: IpynbOutput      -- ^ How to treat ipynb output blocks
    , Opt -> [FilePath]
optIncludeBeforeBody     :: [FilePath]       -- ^ Files to include before
    , Opt -> [FilePath]
optIncludeAfterBody      :: [FilePath]       -- ^ Files to include after body
    , Opt -> [FilePath]
optIncludeInHeader       :: [FilePath]       -- ^ Files to include in header
    , Opt -> [FilePath]
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 FilePath
optCSL                   :: Maybe FilePath -- ^ CSL stylesheet
    , Opt -> [FilePath]
optBibliography          :: [FilePath]  -- ^ Bibliography files
    , Opt -> Maybe FilePath
optCitationAbbreviations :: Maybe FilePath -- ^ Citation abbreviations
    } 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 -> FilePath
(Int -> Opt -> ShowS)
-> (Opt -> FilePath) -> ([Opt] -> ShowS) -> Show Opt
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
showList :: [Opt] -> ShowS
$cshowList :: [Opt] -> ShowS
show :: Opt -> FilePath
$cshow :: Opt -> FilePath
showsPrec :: Int -> Opt -> ShowS
$cshowsPrec :: Int -> Opt -> ShowS
Show)

instance FromYAML (Opt -> Opt) where
  parseYAML :: Node Pos -> Parser (Opt -> Opt)
parseYAML (Mapping Pos
_ Tag
_ Mapping Pos
m) = ((Node Pos, Node Pos) -> Parser (Opt -> Opt))
-> [(Node Pos, Node Pos)] -> Parser (Opt -> Opt)
forall (m :: * -> *) a b.
Monad m =>
(a -> m (b -> b)) -> [a] -> m (b -> b)
chain (Node Pos, Node Pos) -> Parser (Opt -> Opt)
doOpt (Mapping Pos -> [(Node Pos, Node Pos)]
forall k a. Map k a -> [(k, a)]
M.toList Mapping Pos
m)
  parseYAML Node Pos
n = Node Pos -> FilePath -> Parser (Opt -> Opt)
forall a. Node Pos -> FilePath -> Parser a
failAtNode Node Pos
n FilePath
"Expected a mapping"

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

instance (PandocMonad m, MonadIO m)
      => FromYAML (Opt -> StateT DefaultsState m Opt) where
  parseYAML :: Node Pos -> Parser (Opt -> StateT DefaultsState m Opt)
parseYAML (Mapping Pos
_ Tag
_ Mapping Pos
m) = do
    let opts :: Map Text (Node Pos)
opts = (Node Pos -> Text) -> Mapping Pos -> Map Text (Node Pos)
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
M.mapKeys Node Pos -> Text
forall {loc}. Node loc -> Text
toText Mapping Pos
m
    Maybe FilePath
dataDir <- case Text -> Map Text (Node Pos) -> Maybe (Node Pos)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
"data-dir" Map Text (Node Pos)
opts of
      Maybe (Node Pos)
Nothing -> Maybe FilePath -> Parser (Maybe FilePath)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FilePath
forall a. Maybe a
Nothing
      Just Node Pos
v -> FilePath -> Maybe FilePath
forall a. a -> Maybe a
Just (FilePath -> Maybe FilePath)
-> (Text -> FilePath) -> Text -> Maybe FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> FilePath
unpack (Text -> Maybe FilePath) -> Parser Text -> Parser (Maybe FilePath)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
v
    Opt -> StateT DefaultsState m Opt
f <- [(Node Pos, Node Pos)]
-> Parser (Opt -> StateT DefaultsState m Opt)
forall (m :: * -> *).
Monad m =>
[(Node Pos, Node Pos)]
-> Parser (Opt -> StateT DefaultsState m Opt)
parseOptions (Mapping Pos -> [(Node Pos, Node Pos)]
forall k a. Map k a -> [(k, a)]
M.toList Mapping Pos
m)
    case Text -> Map Text (Node Pos) -> Maybe (Node Pos)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
"defaults" Map Text (Node Pos)
opts of
      Just Node Pos
v -> do
        Opt -> StateT DefaultsState m Opt
g <- Node Pos
-> Maybe FilePath -> Parser (Opt -> StateT DefaultsState m Opt)
forall (m :: * -> *).
(PandocMonad m, MonadIO m) =>
Node Pos
-> Maybe FilePath -> Parser (Opt -> StateT DefaultsState m Opt)
parseDefaults Node Pos
v Maybe FilePath
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 (Node Pos)
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
    where
      toText :: Node loc -> Text
toText (Scalar loc
_ (SStr Text
s)) = Text
s
      toText Node loc
_ = Text
""
  parseYAML Node Pos
n = Node Pos -> FilePath -> Parser (Opt -> StateT DefaultsState m Opt)
forall a. Node Pos -> FilePath -> Parser a
failAtNode Node Pos
n FilePath
"Expected a mapping"

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

 where
  resolveVars :: FilePath -> StateT DefaultsState m FilePath
  resolveVars :: FilePath -> StateT DefaultsState m FilePath
resolveVars [] = FilePath -> StateT DefaultsState m FilePath
forall (m :: * -> *) a. Monad m => a -> m a
return []
  resolveVars (Char
'$':Char
'{':FilePath
xs) =
    let (FilePath
ys, FilePath
zs) = (Char -> Bool) -> FilePath -> (FilePath, FilePath)
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
'}') FilePath
xs
     in if FilePath -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null FilePath
zs
           then FilePath -> StateT DefaultsState m FilePath
forall (m :: * -> *) a. Monad m => a -> m a
return (FilePath -> StateT DefaultsState m FilePath)
-> FilePath -> StateT DefaultsState m FilePath
forall a b. (a -> b) -> a -> b
$ Char
'$'Char -> ShowS
forall a. a -> [a] -> [a]
:Char
'{'Char -> ShowS
forall a. a -> [a] -> [a]
:FilePath
xs
           else do
             FilePath
val <- FilePath -> StateT DefaultsState m FilePath
lookupEnv' FilePath
ys
             (FilePath
val FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS
-> StateT DefaultsState m FilePath
-> StateT DefaultsState m FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FilePath -> StateT DefaultsState m FilePath
resolveVars (Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 FilePath
zs)
  resolveVars (Char
c:FilePath
cs) = (Char
cChar -> ShowS
forall a. a -> [a] -> [a]
:) ShowS
-> StateT DefaultsState m FilePath
-> StateT DefaultsState m FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FilePath -> StateT DefaultsState m FilePath
resolveVars FilePath
cs
  lookupEnv' :: String -> StateT DefaultsState m String
  lookupEnv' :: FilePath -> StateT DefaultsState m FilePath
lookupEnv' FilePath
"." = do
    Maybe FilePath
mbCurDefaults <- (DefaultsState -> Maybe FilePath)
-> StateT DefaultsState m (Maybe FilePath)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets DefaultsState -> Maybe FilePath
curDefaults
    StateT DefaultsState m FilePath
-> (FilePath -> StateT DefaultsState m FilePath)
-> Maybe FilePath
-> StateT DefaultsState m FilePath
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (FilePath -> StateT DefaultsState m FilePath
forall (m :: * -> *) a. Monad m => a -> m a
return FilePath
"")
          (ShowS
-> StateT DefaultsState m FilePath
-> StateT DefaultsState m FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ShowS
takeDirectory (StateT DefaultsState m FilePath
 -> StateT DefaultsState m FilePath)
-> (FilePath -> StateT DefaultsState m FilePath)
-> FilePath
-> StateT DefaultsState m FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO FilePath -> StateT DefaultsState m FilePath
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FilePath -> StateT DefaultsState m FilePath)
-> (FilePath -> IO FilePath)
-> FilePath
-> StateT DefaultsState m FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> IO FilePath
canonicalizePath)
          Maybe FilePath
mbCurDefaults
  lookupEnv' FilePath
"USERDATA" = do
    Maybe FilePath
mbodatadir <- (FilePath -> StateT DefaultsState m FilePath)
-> Maybe FilePath -> StateT DefaultsState m (Maybe FilePath)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM FilePath -> StateT DefaultsState m FilePath
resolveVars Maybe FilePath
oDataDir
    Maybe FilePath
mbdatadir  <- StateT DefaultsState m (Maybe FilePath)
forall (m :: * -> *). PandocMonad m => m (Maybe FilePath)
getUserDataDir
    FilePath
defdatadir <- IO FilePath -> StateT DefaultsState m FilePath
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO FilePath
defaultUserDataDir
    FilePath -> StateT DefaultsState m FilePath
forall (m :: * -> *) a. Monad m => a -> m a
return (FilePath -> StateT DefaultsState m FilePath)
-> FilePath -> StateT DefaultsState m FilePath
forall a b. (a -> b) -> a -> b
$ FilePath -> Maybe FilePath -> FilePath
forall a. a -> Maybe a -> a
fromMaybe FilePath
defdatadir (Maybe FilePath
mbodatadir Maybe FilePath -> Maybe FilePath -> Maybe FilePath
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Maybe FilePath
mbdatadir)
  lookupEnv' FilePath
v = do
    Maybe FilePath
mbval <- (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> FilePath
T.unpack (Maybe Text -> Maybe FilePath)
-> StateT DefaultsState m (Maybe Text)
-> StateT DefaultsState m (Maybe FilePath)
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 (FilePath -> Text
T.pack FilePath
v)
    case Maybe FilePath
mbval of
      Maybe FilePath
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 (FilePath -> Text
T.pack FilePath
v)
        FilePath -> StateT DefaultsState m FilePath
forall (m :: * -> *) a. Monad m => a -> m a
return FilePath
forall a. Monoid a => a
mempty
      Just FilePath
x  -> FilePath -> StateT DefaultsState m FilePath
forall (m :: * -> *) a. Monad m => a -> m a
return FilePath
x
  resolveVarsInFilter :: Filter -> StateT DefaultsState m Filter
resolveVarsInFilter (JSONFilter FilePath
fp) =
    FilePath -> Filter
JSONFilter (FilePath -> Filter)
-> StateT DefaultsState m FilePath -> StateT DefaultsState m Filter
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FilePath -> StateT DefaultsState m FilePath
resolveVars FilePath
fp
  resolveVarsInFilter (LuaFilter FilePath
fp) =
    FilePath -> Filter
LuaFilter (FilePath -> Filter)
-> StateT DefaultsState m FilePath -> StateT DefaultsState m Filter
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FilePath -> StateT DefaultsState m FilePath
resolveVars FilePath
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)
              => Node Pos
              -> Maybe FilePath
              -> Parser (Opt -> StateT DefaultsState m Opt)
parseDefaults :: forall (m :: * -> *).
(PandocMonad m, MonadIO m) =>
Node Pos
-> Maybe FilePath -> Parser (Opt -> StateT DefaultsState m Opt)
parseDefaults Node Pos
n Maybe FilePath
dataDir = Node Pos -> Parser [FilePath]
parseDefsNames Node Pos
n Parser [FilePath]
-> ([FilePath] -> 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
>>= \[FilePath]
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:
  FilePath
defsParent <- (DefaultsState -> FilePath) -> StateT DefaultsState m FilePath
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets ((DefaultsState -> FilePath) -> StateT DefaultsState m FilePath)
-> (DefaultsState -> FilePath) -> StateT DefaultsState m FilePath
forall a b. (a -> b) -> a -> b
$ FilePath -> Maybe FilePath -> FilePath
forall a. a -> Maybe a -> a
fromMaybe FilePath
"" (Maybe FilePath -> FilePath)
-> (DefaultsState -> Maybe FilePath) -> DefaultsState -> FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DefaultsState -> Maybe FilePath
curDefaults
  -- get child defaults:
  [FilePath]
defsChildren <- (FilePath -> StateT DefaultsState m FilePath)
-> [FilePath] -> StateT DefaultsState m [FilePath]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (Maybe FilePath -> FilePath -> StateT DefaultsState m FilePath
forall (m :: * -> *).
(PandocMonad m, MonadIO m) =>
Maybe FilePath -> FilePath -> m FilePath
fullDefaultsPath Maybe FilePath
dataDir) [FilePath]
ds
  -- expand parent in defaults inheritance graph by children:
  [[FilePath]]
defsGraph <- (DefaultsState -> [[FilePath]])
-> StateT DefaultsState m [[FilePath]]
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets DefaultsState -> [[FilePath]]
inheritanceGraph
  let defsGraphExp :: [[FilePath]]
defsGraphExp = [[FilePath]] -> [FilePath] -> FilePath -> [[FilePath]]
forall a. Ord a => [[a]] -> [a] -> a -> [[a]]
expand [[FilePath]]
defsGraph [FilePath]
defsChildren FilePath
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 :: [[FilePath]]
inheritanceGraph = [[FilePath]]
defsGraphExp }
  -- check for cyclic inheritance:
  if [[FilePath]] -> Bool
forall a. Ord a => [[a]] -> Bool
cyclic [[FilePath]]
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
$ FilePath -> Text
T.pack (FilePath -> Text) -> FilePath -> Text
forall a b. (a -> b) -> a -> b
$
        FilePath
"Error: Circular defaults file reference in " FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++
        FilePath
"'" FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++ FilePath
defsParent FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++ FilePath
"'"
    else (Opt -> FilePath -> StateT DefaultsState m Opt)
-> Opt -> [FilePath] -> StateT DefaultsState m Opt
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM Opt -> FilePath -> StateT DefaultsState m Opt
forall (m :: * -> *).
(PandocMonad m, MonadIO m) =>
Opt -> FilePath -> StateT DefaultsState m Opt
applyDefaults Opt
o [FilePath]
defsChildren
  where parseDefsNames :: Node Pos -> Parser [FilePath]
parseDefsNames Node Pos
x = (Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
x Parser [Text] -> ([Text] -> Parser [FilePath]) -> Parser [FilePath]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \[Text]
xs -> [FilePath] -> Parser [FilePath]
forall (m :: * -> *) a. Monad m => a -> m a
return ([FilePath] -> Parser [FilePath])
-> [FilePath] -> Parser [FilePath]
forall a b. (a -> b) -> a -> b
$ (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
xs)
                       Parser [FilePath] -> Parser [FilePath] -> Parser [FilePath]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
x Parser Text -> (Text -> Parser [FilePath]) -> Parser [FilePath]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Text
x' -> [FilePath] -> Parser [FilePath]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text -> FilePath
unpack Text
x'])

parseOptions :: Monad m
             => [(Node Pos, Node Pos)]
             -> Parser (Opt -> StateT DefaultsState m Opt)
parseOptions :: forall (m :: * -> *).
Monad m =>
[(Node Pos, Node Pos)]
-> Parser (Opt -> StateT DefaultsState m Opt)
parseOptions [(Node Pos, Node Pos)]
ns = do
  Opt -> Opt
f <- ((Node Pos, Node Pos) -> Parser (Opt -> Opt))
-> [(Node Pos, Node Pos)] -> Parser (Opt -> Opt)
forall (m :: * -> *) a b.
Monad m =>
(a -> m (b -> b)) -> [a] -> m (b -> b)
chain (Node Pos, Node Pos) -> Parser (Opt -> Opt)
doOpt' [(Node Pos, Node Pos)]
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 :: forall (m :: * -> *) a b.
Monad m =>
(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' :: (Node Pos, Node Pos) -> Parser (Opt -> Opt)
doOpt' :: (Node Pos, Node Pos) -> Parser (Opt -> Opt)
doOpt' (Node Pos
k',Node Pos
v) = do
  Text
k <- Node Pos -> Parser Text
parseStringKey Node Pos
k'
  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
_ -> (Node Pos, Node Pos) -> Parser (Opt -> Opt)
doOpt (Node Pos
k',Node Pos
v)

doOpt :: (Node Pos, Node Pos) -> Parser (Opt -> Opt)
doOpt :: (Node Pos, Node Pos) -> Parser (Opt -> Opt)
doOpt (Node Pos
k',Node Pos
v) = do
  Text
k <- Node Pos -> Parser Text
parseStringKey Node Pos
k'
  case Text
k of
    Text
"tab-stop" ->
      Node Pos -> Parser Int
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Int
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 FilePath
optTemplate = Text -> FilePath
unpack (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"variables" ->
      Node Pos -> Parser (Context Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Meta
yamlToMeta Node Pos
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" ->
      Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optMetadataFiles =
                                           Opt -> [FilePath]
optMetadataFiles Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<>
                                           (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x })
    Text
"metadata-file" -> -- allow either a list or a single value
      (Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optMetadataFiles =
                                                Opt -> [FilePath]
optMetadataFiles Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<>
                                                (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optMetadataFiles =
                                           Opt -> [FilePath]
optMetadataFiles Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<>[Text -> FilePath
unpack Text
x] }))
    Text
"output-file" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 FilePath
optOutputFile = Text -> FilePath
unpack (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"input-files" ->
      Node Pos -> Parser (Maybe [Text])
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 [FilePath]
optInputFiles =
                                              Opt -> Maybe [FilePath]
optInputFiles Opt
o Maybe [FilePath] -> Maybe [FilePath] -> Maybe [FilePath]
forall a. Semigroup a => a -> a -> a
<>
                                                ((Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack ([Text] -> [FilePath]) -> Maybe [Text] -> Maybe [FilePath]
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
      (Node Pos -> Parser (Maybe [Text])
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 [FilePath]
optInputFiles =
                                                Opt -> Maybe [FilePath]
optInputFiles Opt
o Maybe [FilePath] -> Maybe [FilePath] -> Maybe [FilePath]
forall a. Semigroup a => a -> a -> a
<>
                                                  ((Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack ([Text] -> [FilePath]) -> Maybe [Text] -> Maybe [FilePath]
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
<|>
      (Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 [FilePath]
optInputFiles =
                                                Opt -> Maybe [FilePath]
optInputFiles Opt
o Maybe [FilePath] -> Maybe [FilePath] -> Maybe [FilePath]
forall a. Semigroup a => a -> a -> a
<>
                                                ((\Text
z -> [Text -> FilePath
unpack Text
z]) (Text -> [FilePath]) -> Maybe Text -> Maybe [FilePath]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x)
                                            }))
    Text
"number-sections" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser [Int]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      (Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optSyntaxDefinitions =
                                   Opt -> [FilePath]
optSyntaxDefinitions Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<> (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optSyntaxDefinitions =
                                 Opt -> [FilePath]
optSyntaxDefinitions Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<> [Text -> FilePath
unpack Text
x] }))
    Text
"syntax-definitions" ->
      Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optSyntaxDefinitions =
                                Opt -> [FilePath]
optSyntaxDefinitions Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<> (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x })
    Text
"top-level-division" ->
      Node Pos -> Parser TopLevelDivision
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser HTMLMathMethod
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 FilePath
optAbbreviations = Text -> FilePath
unpack (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"reference-doc" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 FilePath
optReferenceDoc = Text -> FilePath
unpack (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"epub-subdirectory" ->
      Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: FilePath
optEpubSubdirectory = Text -> FilePath
unpack Text
x })
    Text
"epub-metadata" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 FilePath
optEpubMetadata = Text -> FilePath
unpack (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"epub-fonts" ->
      Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optEpubFonts = Opt -> [FilePath]
optEpubFonts Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<>
                                               (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x })
    Text
"epub-chapter-level" ->
      Node Pos -> Parser Int
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 FilePath
optEpubCoverImage = Text -> FilePath
unpack (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"toc-depth" ->
      Node Pos -> Parser Int
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Verbosity
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 FilePath
optLogFile = Text -> FilePath
unpack (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"fail-if-warnings" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser ReferenceLocation
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Int
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser WrapOption
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Int
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser [Filter]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser ObfuscationMethod
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 FilePath
optDataDir = Text -> FilePath
unpack (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"cite-method" ->
      Node Pos -> Parser CiteMethod
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 FilePath
optPdfEngine = Text -> FilePath
unpack (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"pdf-engine-opts" ->
      Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optPdfEngineOpts = (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x })
    Text
"pdf-engine-opt" ->
      (Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optPdfEngineOpts = (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optPdfEngineOpts = [Text -> FilePath
unpack Text
x] }))
    Text
"slide-level" ->
      Node Pos -> Parser (Maybe Int)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 FilePath
optExtractMedia = Text -> FilePath
unpack (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"track-changes" ->
      Node Pos -> Parser TrackChanges
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      (Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optCss = Opt -> [FilePath]
optCss Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<>
                                                 (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optCss = Opt -> [FilePath]
optCss Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<>
                                                [Text -> FilePath
unpack Text
x] }))
    Text
"bibliography" ->
      (Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optBibliography = Opt -> [FilePath]
optBibliography Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<>
                                                      (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optBibliography = Opt -> [FilePath]
optBibliography Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<>
                                                       [Text -> FilePath
unpack Text
x] }))
    Text
"csl" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 FilePath
optCSL = Text -> FilePath
unpack (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"citation-abbreviations" ->
      Node Pos -> Parser (Maybe Text)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 FilePath
optCitationAbbreviations =
                                                  Text -> FilePath
unpack (Text -> FilePath) -> Maybe Text -> Maybe FilePath
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"ipynb-output" ->
      Node Pos -> Parser IpynbOutput
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      (Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optIncludeBeforeBody =
                                Opt -> [FilePath]
optIncludeBeforeBody Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<> (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optIncludeBeforeBody =
                                Opt -> [FilePath]
optIncludeBeforeBody Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<> [Text -> FilePath
unpack Text
x] }))
    Text
"include-after-body" ->
      (Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optIncludeAfterBody =
                                Opt -> [FilePath]
optIncludeAfterBody Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<> (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optIncludeAfterBody =
                                Opt -> [FilePath]
optIncludeAfterBody Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<> [Text -> FilePath
unpack Text
x] }))
    Text
"include-in-header" ->
      (Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optIncludeInHeader =
                                Opt -> [FilePath]
optIncludeInHeader Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<> (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optIncludeInHeader =
                                Opt -> [FilePath]
optIncludeInHeader Opt
o [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<> [Text -> FilePath
unpack Text
x] }))
    Text
"resource-path" ->
      Node Pos -> Parser [Text]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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 :: [FilePath]
optResourcePath = (Text -> FilePath) -> [Text] -> [FilePath]
forall a b. (a -> b) -> [a] -> [b]
map Text -> FilePath
unpack [Text]
x [FilePath] -> [FilePath] -> [FilePath]
forall a. Semigroup a => a -> a -> a
<>
                                 Opt -> [FilePath]
optResourcePath Opt
o })
    Text
"request-headers" ->
      Node Pos -> Parser [(Text, Text)]
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser LineEnding
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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" ->
      Node Pos -> Parser Bool
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
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
_ -> Node Pos -> FilePath -> Parser (Opt -> Opt)
forall a. Node Pos -> FilePath -> Parser a
failAtNode Node Pos
k' (FilePath -> Parser (Opt -> Opt))
-> FilePath -> Parser (Opt -> Opt)
forall a b. (a -> b) -> a -> b
$ FilePath
"Unknown option " FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> FilePath
forall a. Show a => a -> FilePath
show Text
k

-- | Defaults for command-line options.
defaultOpts :: Opt
defaultOpts :: Opt
defaultOpts = Opt :: Int
-> Bool
-> Bool
-> Maybe Text
-> Maybe Text
-> Bool
-> Int
-> Maybe FilePath
-> Context Text
-> Meta
-> [FilePath]
-> Maybe FilePath
-> Maybe [FilePath]
-> Bool
-> [Int]
-> Bool
-> Bool
-> Bool
-> Bool
-> Maybe Text
-> [FilePath]
-> TopLevelDivision
-> HTMLMathMethod
-> Maybe FilePath
-> Maybe FilePath
-> FilePath
-> Maybe FilePath
-> [FilePath]
-> Int
-> Maybe FilePath
-> Int
-> Bool
-> Bool
-> Verbosity
-> Bool
-> Maybe FilePath
-> Bool
-> Bool
-> ReferenceLocation
-> Int
-> WrapOption
-> Int
-> [Filter]
-> ObfuscationMethod
-> Text
-> Bool
-> [Text]
-> Maybe FilePath
-> CiteMethod
-> Bool
-> Maybe FilePath
-> [FilePath]
-> Maybe Int
-> Bool
-> Bool
-> Text
-> Maybe FilePath
-> TrackChanges
-> Bool
-> Maybe Text
-> [FilePath]
-> IpynbOutput
-> [FilePath]
-> [FilePath]
-> [FilePath]
-> [FilePath]
-> [(Text, Text)]
-> Bool
-> LineEnding
-> Bool
-> Maybe FilePath
-> [FilePath]
-> Maybe FilePath
-> 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 FilePath
optTemplate              = Maybe FilePath
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 :: [FilePath]
optMetadataFiles         = []
    , optOutputFile :: Maybe FilePath
optOutputFile            = Maybe FilePath
forall a. Maybe a
Nothing
    , optInputFiles :: Maybe [FilePath]
optInputFiles            = Maybe [FilePath]
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 :: [FilePath]
optSyntaxDefinitions     = []
    , optTopLevelDivision :: TopLevelDivision
optTopLevelDivision      = TopLevelDivision
TopLevelDefault
    , optHTMLMathMethod :: HTMLMathMethod
optHTMLMathMethod        = HTMLMathMethod
PlainMath
    , optAbbreviations :: Maybe FilePath
optAbbreviations         = Maybe FilePath
forall a. Maybe a
Nothing
    , optReferenceDoc :: Maybe FilePath
optReferenceDoc          = Maybe FilePath
forall a. Maybe a
Nothing
    , optEpubSubdirectory :: FilePath
optEpubSubdirectory      = FilePath
"EPUB"
    , optEpubMetadata :: Maybe FilePath
optEpubMetadata          = Maybe FilePath
forall a. Maybe a
Nothing
    , optEpubFonts :: [FilePath]
optEpubFonts             = []
    , optEpubChapterLevel :: Int
optEpubChapterLevel      = Int
1
    , optEpubCoverImage :: Maybe FilePath
optEpubCoverImage        = Maybe FilePath
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 FilePath
optLogFile               = Maybe FilePath
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 FilePath
optDataDir               = Maybe FilePath
forall a. Maybe a
Nothing
    , optCiteMethod :: CiteMethod
optCiteMethod            = CiteMethod
Citeproc
    , optListings :: Bool
optListings              = Bool
False
    , optPdfEngine :: Maybe FilePath
optPdfEngine             = Maybe FilePath
forall a. Maybe a
Nothing
    , optPdfEngineOpts :: [FilePath]
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 FilePath
optExtractMedia          = Maybe FilePath
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 :: [FilePath]
optCss                   = []
    , optIpynbOutput :: IpynbOutput
optIpynbOutput           = IpynbOutput
IpynbOutputBest
    , optIncludeBeforeBody :: [FilePath]
optIncludeBeforeBody     = []
    , optIncludeAfterBody :: [FilePath]
optIncludeAfterBody      = []
    , optIncludeInHeader :: [FilePath]
optIncludeInHeader       = []
    , optResourcePath :: [FilePath]
optResourcePath          = [FilePath
"."]
    , optRequestHeaders :: [(Text, Text)]
optRequestHeaders        = []
    , optNoCheckCertificate :: Bool
optNoCheckCertificate    = Bool
False
    , optEol :: LineEnding
optEol                   = LineEnding
Native
    , optStripComments :: Bool
optStripComments         = Bool
False
    , optCSL :: Maybe FilePath
optCSL                   = Maybe FilePath
forall a. Maybe a
Nothing
    , optBibliography :: [FilePath]
optBibliography          = []
    , optCitationAbbreviations :: Maybe FilePath
optCitationAbbreviations = Maybe FilePath
forall a. Maybe a
Nothing
    }

parseStringKey ::  Node Pos -> Parser Text
parseStringKey :: Node Pos -> Parser Text
parseStringKey Node Pos
k = case Node Pos
k of
  Scalar Pos
_ (SStr Text
t) -> Text -> Parser Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
t
  Scalar Pos
_ Scalar
_ -> Node Pos -> FilePath -> Parser Text
forall a. Node Pos -> FilePath -> Parser a
failAtNode Node Pos
k FilePath
"Non-string key"
  Node Pos
_ -> Node Pos -> FilePath -> Parser Text
forall a. Node Pos -> FilePath -> Parser a
failAtNode Node Pos
k FilePath
"Non-scalar key"

yamlToMeta :: Node Pos -> Parser Meta
yamlToMeta :: Node Pos -> Parser Meta
yamlToMeta (Mapping Pos
_ Tag
_ Mapping Pos
m) =
    (PandocError -> Parser Meta)
-> (Meta -> Parser Meta) -> Either PandocError Meta -> Parser Meta
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (FilePath -> Parser Meta
forall (m :: * -> *) a. MonadFail m => FilePath -> m a
fail (FilePath -> Parser Meta)
-> (PandocError -> FilePath) -> PandocError -> Parser Meta
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PandocError -> FilePath
forall a. Show a => a -> FilePath
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
  Text
  ParserState
  PandocPure
  (Future ParserState (Map Text MetaValue))
-> Either PandocError Meta
forall {b}.
Default b =>
ParserT Text ParserState PandocPure (Future b (Map Text MetaValue))
-> Either PandocError Meta
runEverything (ParserT Text ParserState PandocPure (Future ParserState MetaValue)
-> Mapping Pos
-> ParserT
     Text
     ParserState
     PandocPure
     (Future ParserState (Map Text MetaValue))
forall (m :: * -> *) st.
(PandocMonad m, HasLastStrPosition st) =>
ParserT Text st m (Future st MetaValue)
-> Mapping Pos
-> ParserT Text st m (Future st (Map Text MetaValue))
yamlMap ParserT Text ParserState PandocPure (Future ParserState MetaValue)
forall {st}.
ParsecT Text st PandocPure (Future ParserState MetaValue)
pMetaString Mapping Pos
m)
  where
    pMetaString :: ParsecT Text 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 Text st PandocPure Text
-> ParsecT Text st PandocPure (Future ParserState MetaValue)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserT Text st PandocPure Char -> ParsecT Text 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 Text st PandocPure Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
P.anyChar
    runEverything :: ParserT Text ParserState PandocPure (Future b (Map Text MetaValue))
-> Either PandocError Meta
runEverything ParserT Text ParserState PandocPure (Future b (Map Text MetaValue))
p =
      PandocPure (Either PandocError (Future b (Map Text MetaValue)))
-> Either
     PandocError (Either PandocError (Future b (Map Text MetaValue)))
forall a. PandocPure a -> Either PandocError a
runPure (ParserT Text ParserState PandocPure (Future b (Map Text MetaValue))
-> ParserState
-> Text
-> PandocPure (Either PandocError (Future b (Map Text MetaValue)))
forall (m :: * -> *) st a.
Monad m =>
ParserT Text st m a -> st -> Text -> m (Either PandocError a)
P.readWithM ParserT Text ParserState PandocPure (Future b (Map Text MetaValue))
p (ParserState
forall a. Default a => a
def :: P.ParserState) Text
"")
      Either
  PandocError (Either PandocError (Future b (Map Text MetaValue)))
-> (Either PandocError (Future b (Map Text MetaValue))
    -> Either PandocError Meta)
-> Either PandocError Meta
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Future b (Map Text MetaValue) -> Meta)
-> Either PandocError (Future b (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 b (Map Text MetaValue) -> Map Text MetaValue)
-> Future b (Map Text MetaValue)
-> Meta
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Future b (Map Text MetaValue) -> b -> Map Text MetaValue)
-> b -> Future b (Map Text MetaValue) -> Map Text MetaValue
forall a b c. (a -> b -> c) -> b -> a -> c
flip Future b (Map Text MetaValue) -> b -> Map Text MetaValue
forall s a. Future s a -> s -> a
P.runF b
forall a. Default a => a
def)
yamlToMeta Node Pos
_ = 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 :: forall (m :: * -> *).
(PandocMonad m, MonadIO m) =>
Opt -> FilePath -> StateT DefaultsState m Opt
applyDefaults Opt
opt FilePath
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 FilePath
curDefaults = FilePath -> Maybe FilePath
forall a. a -> Maybe a
Just FilePath
file }
  ByteString
inp <- FilePath -> StateT DefaultsState m ByteString
forall (m :: * -> *). PandocMonad m => FilePath -> m ByteString
readFileLazy FilePath
file
  case ByteString
-> Either (Pos, FilePath) (Opt -> StateT DefaultsState m Opt)
forall v. FromYAML v => ByteString -> Either (Pos, FilePath) v
decode1 ByteString
inp of
      Right Opt -> StateT DefaultsState m Opt
f -> Opt -> StateT DefaultsState m Opt
f Opt
opt
      Left (Pos
errpos, FilePath
errmsg)  -> 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
$ FilePath -> Text
T.pack (FilePath -> Text) -> FilePath -> Text
forall a b. (a -> b) -> a -> b
$
         FilePath
"Error parsing " FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++ FilePath
file FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++ FilePath
" line " FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++
          Int -> FilePath
forall a. Show a => a -> FilePath
show (Pos -> Int
posLine Pos
errpos) FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++ FilePath
" column " FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++
          Int -> FilePath
forall a. Show a => a -> FilePath
show (Pos -> Int
posColumn Pos
errpos) FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++ FilePath
":\n" FilePath -> ShowS
forall a. [a] -> [a] -> [a]
++ FilePath
errmsg

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

-- see https://github.com/jgm/pandoc/pull/4083
-- using generic deriving caused long compilation times
$(deriveJSON
   defaultOptions{ fieldLabelModifier = drop 11 . map toLower } ''IpynbOutput)
$(deriveJSON
   defaultOptions{ fieldLabelModifier = map toLower } ''LineEnding)
$(deriveJSON
   defaultOptions{ fieldLabelModifier =
                      camelCaseStrToHyphenated . dropWhile isLower
                 } ''Opt)