{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE OverloadedStrings   #-}
{-# LANGUAGE CPP                 #-}
{-# LANGUAGE DeriveGeneric       #-}
{-# LANGUAGE TemplateHaskell     #-}
{-# LANGUAGE FlexibleInstances   #-}
{-# LANGUAGE FlexibleContexts    #-}
{- |
   Module      : Text.Pandoc.App.Opt
   Copyright   : Copyright (C) 2006-2020 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 (..)
          , defaultOpts
          , addMeta
          ) where
import Data.Char (isLower, toLower)
import GHC.Generics hiding (Meta)
import Text.Pandoc.Builder (setMeta)
import Text.Pandoc.Filter (Filter (..))
import Text.Pandoc.Logging (Verbosity (WARNING))
import Text.Pandoc.Options (TopLevelDivision (TopLevelDefault),
                            TrackChanges (AcceptChanges),
                            WrapOption (WrapAuto), HTMLMathMethod (PlainMath),
                            ReferenceLocation (EndOfDocument),
                            ObfuscationMethod (NoObfuscation),
                            CiteMethod (Citeproc))
import Text.Pandoc.Shared (camelCaseStrToHyphenated)
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(..), lookupMeta)
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 -> String
(Int -> LineEnding -> ShowS)
-> (LineEnding -> String)
-> ([LineEnding] -> ShowS)
-> Show LineEnding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LineEnding] -> ShowS
$cshowList :: [LineEnding] -> ShowS
show :: LineEnding -> String
$cshow :: LineEnding -> String
showsPrec :: Int -> LineEnding -> ShowS
$cshowsPrec :: Int -> LineEnding -> ShowS
Show, (forall x. LineEnding -> Rep LineEnding x)
-> (forall x. Rep LineEnding x -> LineEnding) -> Generic LineEnding
forall x. Rep LineEnding x -> LineEnding
forall x. LineEnding -> Rep LineEnding x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LineEnding x -> LineEnding
$cfrom :: forall x. LineEnding -> Rep LineEnding x
Generic)

instance FromYAML LineEnding where
  parseYAML :: Node Pos -> Parser LineEnding
parseYAML = String
-> (Text -> Parser LineEnding) -> Node Pos -> Parser LineEnding
forall a. String -> (Text -> Parser a) -> Node Pos -> Parser a
withStr String
"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
_        -> String -> Parser LineEnding
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser LineEnding) -> String -> Parser LineEnding
forall a b. (a -> b) -> a -> b
$ String
"Unknown line ending type " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
forall a. Show a => a -> String
show Text
t

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

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

instance FromYAML (Opt -> Opt) where
  parseYAML :: Node Pos -> Parser (Opt -> Opt)
parseYAML (Mapping Pos
_ Tag
_ Mapping Pos
m) =
    ((Opt -> Opt) -> (Opt -> Opt) -> Opt -> Opt)
-> (Opt -> Opt) -> [Opt -> Opt] -> Opt -> Opt
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (Opt -> Opt) -> (Opt -> Opt) -> Opt -> Opt
forall b c a. (b -> c) -> (a -> b) -> a -> c
(.) Opt -> Opt
forall a. a -> a
id ([Opt -> Opt] -> Opt -> Opt)
-> Parser [Opt -> Opt] -> Parser (Opt -> Opt)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Node Pos, Node Pos) -> Parser (Opt -> Opt))
-> [(Node Pos, Node Pos)] -> Parser [Opt -> Opt]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (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 -> String -> Parser (Opt -> Opt)
forall a. Node Pos -> String -> Parser a
failAtNode Node Pos
n String
"Expected a mapping"

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 <- 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 -> String -> Parser Text
forall a. Node Pos -> String -> Parser a
failAtNode Node Pos
k' String
"Non-string key"
         Node Pos
_ -> Node Pos -> String -> Parser Text
forall a. Node Pos -> String -> Parser a
failAtNode Node Pos
k' String
"Non-scalar key"
  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 String
optTemplate = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"variables" ->
      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 :: [String]
optMetadataFiles =
                                           Opt -> [String]
optMetadataFiles Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                           (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x })
    Text
"metadata-file" -> -- allow either a list or a single value
      (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 :: [String]
optMetadataFiles =
                                                Opt -> [String]
optMetadataFiles Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                                (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (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 :: [String]
optMetadataFiles =
                                           Opt -> [String]
optMetadataFiles Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>[Text -> String
unpack Text
x] }))
    Text
"output-file" ->
      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 String
optOutputFile = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"input-files" ->
      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 [String]
optInputFiles =
                                              Opt -> Maybe [String]
optInputFiles Opt
o Maybe [String] -> Maybe [String] -> Maybe [String]
forall a. Semigroup a => a -> a -> a
<>
                                                ((Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack ([Text] -> [String]) -> Maybe [Text] -> Maybe [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe [Text]
x) })
    Text
"input-file" -> -- allow either a list or a single value
      (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 [String]
optInputFiles =
                                                Opt -> Maybe [String]
optInputFiles Opt
o Maybe [String] -> Maybe [String] -> Maybe [String]
forall a. Semigroup a => a -> a -> a
<>
                                                  ((Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack ([Text] -> [String]) -> Maybe [Text] -> Maybe [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe [Text]
x) }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (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 [String]
optInputFiles =
                                                Opt -> Maybe [String]
optInputFiles Opt
o Maybe [String] -> Maybe [String] -> Maybe [String]
forall a. Semigroup a => a -> a -> a
<>
                                                ((\Text
z -> [Text -> String
unpack Text
z]) (Text -> [String]) -> Maybe Text -> Maybe [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x)
                                            }))
    Text
"number-sections" ->
      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 :: [String]
optSyntaxDefinitions =
                                   Opt -> [String]
optSyntaxDefinitions Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (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 :: [String]
optSyntaxDefinitions =
                                 Opt -> [String]
optSyntaxDefinitions Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [Text -> String
unpack Text
x] }))
    Text
"syntax-definitions" ->
      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 :: [String]
optSyntaxDefinitions =
                                Opt -> [String]
optSyntaxDefinitions Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x })
    Text
"top-level-division" ->
      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 String
optAbbreviations = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"reference-doc" ->
      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 String
optReferenceDoc = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"epub-subdirectory" ->
      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 :: String
optEpubSubdirectory = Text -> String
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 String
optEpubMetadata = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"epub-fonts" ->
      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 :: [String]
optEpubFonts = Opt -> [String]
optEpubFonts Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                               (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x })
    Text
"epub-chapter-level" ->
      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 String
optEpubCoverImage = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"toc-depth" ->
      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 String
optLogFile = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"fail-if-warnings" ->
      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 String
optDataDir = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"cite-method" ->
      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 String
optPdfEngine = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"pdf-engine-opts" ->
      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 :: [String]
optPdfEngineOpts = (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
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 :: [String]
optPdfEngineOpts = (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (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 :: [String]
optPdfEngineOpts = [Text -> String
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 String
optExtractMedia = Text -> String
unpack (Text -> String) -> Maybe Text -> Maybe String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text
x })
    Text
"track-changes" ->
      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 :: [String]
optCss = Opt -> [String]
optCss Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                                 (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (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 :: [String]
optCss = Opt -> [String]
optCss Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<>
                                                [Text -> String
unpack Text
x] }))
    Text
"bibliography" ->
      do let addItem :: Text -> Opt -> Opt
addItem Text
x Opt
o = Opt
o{ optMetadata :: Meta
optMetadata =
                                 String -> String -> Meta -> Meta
addMeta String
"bibliography" (Text -> String
T.unpack Text
x)
                                    (Opt -> Meta
optMetadata Opt
o) }
         (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]
xs :: [Text]) -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return ((Opt -> Opt) -> Parser (Opt -> Opt))
-> (Opt -> Opt) -> Parser (Opt -> Opt)
forall a b. (a -> b) -> a -> b
$ \Opt
o ->
                                                    (Text -> Opt -> Opt) -> Opt -> [Text] -> Opt
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Text -> Opt -> Opt
addItem Opt
o [Text]
xs)
          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 :: Text) -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return ((Opt -> Opt) -> Parser (Opt -> Opt))
-> (Opt -> Opt) -> Parser (Opt -> Opt)
forall a b. (a -> b) -> a -> b
$ \Opt
o -> Text -> Opt -> Opt
addItem Text
x Opt
o)
    Text
"csl" ->
      do let addItem :: Text -> Opt -> Opt
addItem Text
x Opt
o = Opt
o{ optMetadata :: Meta
optMetadata =
                                 String -> String -> Meta -> Meta
addMeta String
"csl" (Text -> String
T.unpack Text
x)
                                   (Opt -> Meta
optMetadata Opt
o) }
         (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]
xs :: [Text]) -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return ((Opt -> Opt) -> Parser (Opt -> Opt))
-> (Opt -> Opt) -> Parser (Opt -> Opt)
forall a b. (a -> b) -> a -> b
$ \Opt
o ->
                                                    (Text -> Opt -> Opt) -> Opt -> [Text] -> Opt
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Text -> Opt -> Opt
addItem Opt
o [Text]
xs)
          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 :: Text) -> (Opt -> Opt) -> Parser (Opt -> Opt)
forall (m :: * -> *) a. Monad m => a -> m a
return ((Opt -> Opt) -> Parser (Opt -> Opt))
-> (Opt -> Opt) -> Parser (Opt -> Opt)
forall a b. (a -> b) -> a -> b
$ \Opt
o -> Text -> Opt -> Opt
addItem Text
x Opt
o)
    Text
"citation-abbreviations" ->
      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{ optMetadata :: Meta
optMetadata =
                                String -> String -> Meta -> Meta
addMeta String
"citation-abbreviations" (Text -> String
T.unpack Text
x)
                                  (Opt -> Meta
optMetadata Opt
o) })
    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 :: [String]
optIncludeBeforeBody =
                                Opt -> [String]
optIncludeBeforeBody Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (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 :: [String]
optIncludeBeforeBody =
                                Opt -> [String]
optIncludeBeforeBody Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [Text -> String
unpack Text
x] }))
    Text
"include-after-body" ->
      (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 :: [String]
optIncludeAfterBody =
                                Opt -> [String]
optIncludeAfterBody Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (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 :: [String]
optIncludeAfterBody =
                                Opt -> [String]
optIncludeAfterBody Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [Text -> String
unpack Text
x] }))
    Text
"include-in-header" ->
      (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 :: [String]
optIncludeInHeader =
                                Opt -> [String]
optIncludeInHeader Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x }))
      Parser (Opt -> Opt) -> Parser (Opt -> Opt) -> Parser (Opt -> Opt)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      (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 :: [String]
optIncludeInHeader =
                                Opt -> [String]
optIncludeInHeader Opt
o [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
<> [Text -> String
unpack Text
x] }))
    Text
"resource-path" ->
      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 :: [String]
optResourcePath = (Text -> String) -> [Text] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map Text -> String
unpack [Text]
x })
    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 -> String -> Parser (Opt -> Opt)
forall a. Node Pos -> String -> Parser a
failAtNode Node Pos
k' (String -> Parser (Opt -> Opt)) -> String -> Parser (Opt -> Opt)
forall a b. (a -> b) -> a -> b
$ String
"Unknown option " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
forall a. Show a => a -> String
show Text
k

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

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 (String -> Parser Meta
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Parser Meta)
-> (PandocError -> String) -> PandocError -> Parser Meta
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PandocError -> String
forall a. Show a => a -> String
show) Meta -> Parser Meta
forall (m :: * -> *) a. Monad m => a -> m a
return (Either PandocError Meta -> Parser Meta)
-> Either PandocError Meta -> Parser Meta
forall a b. (a -> b) -> a -> b
$ ParserT
  Text
  ParserState
  PandocPure
  (Future ParserState (Map Text MetaValue))
-> Either PandocError Meta
forall s st s.
(Stream s PandocPure Char, ToText s, IsString s, Default st,
 Default s) =>
ParserT s st PandocPure (Future s (Map Text MetaValue))
-> Either PandocError Meta
runEverything (ParserT Text ParserState PandocPure (F MetaValue)
-> Mapping Pos
-> ParserT
     Text
     ParserState
     PandocPure
     (Future ParserState (Map Text MetaValue))
forall (m :: * -> *).
PandocMonad m =>
ParserT Text ParserState m (F MetaValue)
-> Mapping Pos
-> ParserT
     Text ParserState m (Future ParserState (Map Text MetaValue))
yamlMap ParserT Text ParserState PandocPure (F MetaValue)
forall st. ParsecT Text st PandocPure (F MetaValue)
pMetaString Mapping Pos
m)
  where
    pMetaString :: ParsecT Text st PandocPure (F MetaValue)
pMetaString = MetaValue -> F MetaValue
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MetaValue -> F MetaValue)
-> (Text -> MetaValue) -> Text -> F MetaValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> MetaValue
MetaString (Text -> F MetaValue)
-> ParsecT Text st PandocPure Text
-> ParsecT Text st PandocPure (F 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 s st PandocPure (Future s (Map Text MetaValue))
-> Either PandocError Meta
runEverything ParserT s st PandocPure (Future s (Map Text MetaValue))
p = PandocPure (Either PandocError (Future s (Map Text MetaValue)))
-> Either
     PandocError (Either PandocError (Future s (Map Text MetaValue)))
forall a. PandocPure a -> Either PandocError a
runPure (ParserT s st PandocPure (Future s (Map Text MetaValue))
-> st
-> s
-> PandocPure (Either PandocError (Future s (Map Text MetaValue)))
forall s (m :: * -> *) st a.
(Stream s m Char, ToText s) =>
ParserT s st m a -> st -> s -> m (Either PandocError a)
P.readWithM ParserT s st PandocPure (Future s (Map Text MetaValue))
p st
forall a. Default a => a
def s
"")
      Either
  PandocError (Either PandocError (Future s (Map Text MetaValue)))
-> (Either PandocError (Future s (Map Text MetaValue))
    -> Either PandocError Meta)
-> Either PandocError Meta
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Future s (Map Text MetaValue) -> Meta)
-> Either PandocError (Future s (Map Text MetaValue))
-> Either PandocError Meta
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Map Text MetaValue -> Meta
Meta (Map Text MetaValue -> Meta)
-> (Future s (Map Text MetaValue) -> Map Text MetaValue)
-> Future s (Map Text MetaValue)
-> Meta
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Future s (Map Text MetaValue) -> s -> Map Text MetaValue)
-> s -> Future s (Map Text MetaValue) -> Map Text MetaValue
forall a b c. (a -> b -> c) -> b -> a -> c
flip Future s (Map Text MetaValue) -> s -> Map Text MetaValue
forall s a. Future s a -> s -> a
P.runF s
forall a. Default a => a
def)
yamlToMeta Node Pos
_ = Meta -> Parser Meta
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
forall a. Monoid a => a
mempty

addMeta :: String -> String -> Meta -> Meta
addMeta :: String -> String -> Meta -> Meta
addMeta String
k String
v Meta
meta =
  case Text -> Meta -> Maybe MetaValue
lookupMeta Text
k' Meta
meta of
       Maybe MetaValue
Nothing -> Text -> MetaValue -> Meta -> Meta
forall a b. (HasMeta a, ToMetaValue b) => Text -> b -> a -> a
setMeta Text
k' MetaValue
v' Meta
meta
       Just (MetaList [MetaValue]
xs) ->
                  Text -> MetaValue -> Meta -> Meta
forall a b. (HasMeta a, ToMetaValue b) => Text -> b -> a -> a
setMeta Text
k' ([MetaValue] -> MetaValue
MetaList ([MetaValue]
xs [MetaValue] -> [MetaValue] -> [MetaValue]
forall a. [a] -> [a] -> [a]
++ [MetaValue
v'])) Meta
meta
       Just MetaValue
x  -> Text -> MetaValue -> Meta -> Meta
forall a b. (HasMeta a, ToMetaValue b) => Text -> b -> a -> a
setMeta Text
k' ([MetaValue] -> MetaValue
MetaList [MetaValue
x, MetaValue
v']) Meta
meta
 where
  v' :: MetaValue
v' = String -> MetaValue
readMetaValue String
v
  k' :: Text
k' = String -> Text
T.pack String
k

readMetaValue :: String -> MetaValue
readMetaValue :: String -> MetaValue
readMetaValue String
s
  | String
s String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"true"  = Bool -> MetaValue
MetaBool Bool
True
  | String
s String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"True"  = Bool -> MetaValue
MetaBool Bool
True
  | String
s String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"TRUE"  = Bool -> MetaValue
MetaBool Bool
True
  | String
s String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"false" = Bool -> MetaValue
MetaBool Bool
False
  | String
s String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"False" = Bool -> MetaValue
MetaBool Bool
False
  | String
s String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"FALSE" = Bool -> MetaValue
MetaBool Bool
False
  | Bool
otherwise    = Text -> MetaValue
MetaString (Text -> MetaValue) -> Text -> MetaValue
forall a b. (a -> b) -> a -> b
$ String -> Text
T.pack String
s


-- 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)