{-# LANGUAGE OverloadedStrings #-}
{- |
   Module      : Text.Pandoc.Readers.Org.ExportSettings
   Copyright   : © 2016-2023 Albert Krewinkel
   License     : GNU GPL, version 2 or above

   Maintainer  : Albert Krewinkel <tarleb+pandoc@moltkeplatz.de>

Parsers for Org-mode export options.
-}
module Text.Pandoc.Readers.Org.ExportSettings
  ( exportSettings
  ) where

import Text.Pandoc.Class.PandocMonad (PandocMonad, report)
import Text.Pandoc.Logging (LogMessage (UnknownOrgExportOption))
import Text.Pandoc.Readers.Org.ParserState
import Text.Pandoc.Readers.Org.Parsing

import Control.Monad (mzero, void)
import Data.Char (toLower)
import Data.Maybe (listToMaybe)
import Data.Text (Text, unpack)

-- | Read and handle space separated org-mode export settings.
exportSettings :: PandocMonad m => OrgParser m ()
exportSettings :: forall (m :: * -> *). PandocMonad m => OrgParser m ()
exportSettings = forall (f :: * -> *) a. Functor f => f a -> f ()
void forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy forall s (m :: * -> *) st.
(Stream s m Char, UpdateSourcePos s Char) =>
ParsecT s st m ()
skipSpaces forall (m :: * -> *). PandocMonad m => OrgParser m ()
exportSetting

-- | Setter function for export settings.
type ExportSettingSetter a = a -> ExportSettings -> ExportSettings

-- | Read and process a single org-mode export option.
exportSetting :: PandocMonad m => OrgParser m ()
exportSetting :: forall (m :: * -> *). PandocMonad m => OrgParser m ()
exportSetting = forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice
  [ forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"^" (\Bool
val ExportSettings
es -> ExportSettings
es { exportSubSuperscripts :: Bool
exportSubSuperscripts = Bool
val })
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"'" (\Bool
val ExportSettings
es -> ExportSettings
es { exportSmartQuotes :: Bool
exportSmartQuotes = Bool
val })
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"*" (\Bool
val ExportSettings
es -> ExportSettings
es { exportEmphasizedText :: Bool
exportEmphasizedText = Bool
val })
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"-" (\Bool
val ExportSettings
es -> ExportSettings
es { exportSpecialStrings :: Bool
exportSpecialStrings = Bool
val })
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
":"
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
"<"
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"\\n" (\Bool
val ExportSettings
es -> ExportSettings
es { exportPreserveBreaks :: Bool
exportPreserveBreaks = Bool
val })
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter ArchivedTreesOption -> OrgParser m ()
archivedTreeSetting Text
"arch" (\ArchivedTreesOption
val ExportSettings
es -> ExportSettings
es { exportArchivedTrees :: ArchivedTreesOption
exportArchivedTrees = ArchivedTreesOption
val })
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"author" (\Bool
val ExportSettings
es -> ExportSettings
es { exportWithAuthor :: Bool
exportWithAuthor = Bool
val })
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
"c"
  -- org-mode allows the special value `comment` for creator, which we'll
  -- interpret as true as it doesn't make sense in the context of Pandoc.
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"creator" (\Bool
val ExportSettings
es -> ExportSettings
es { exportWithCreator :: Bool
exportWithCreator = Bool
val })
  , forall (m :: * -> *).
Monad m =>
Text
-> ExportSettingSetter (Either [Text] [Text]) -> OrgParser m ()
complementableListSetting Text
"d" (\Either [Text] [Text]
val ExportSettings
es -> ExportSettings
es { exportDrawers :: Either [Text] [Text]
exportDrawers = Either [Text] [Text]
val })
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
"date"
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"e" (\Bool
val ExportSettings
es -> ExportSettings
es { exportWithEntities :: Bool
exportWithEntities = Bool
val })
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"email" (\Bool
val ExportSettings
es -> ExportSettings
es { exportWithEmail :: Bool
exportWithEmail = Bool
val })
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"f" (\Bool
val ExportSettings
es -> ExportSettings
es { exportWithFootnotes :: Bool
exportWithFootnotes = Bool
val })
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Int -> OrgParser m ()
integerSetting Text
"H" (\Int
val ExportSettings
es -> ExportSettings
es { exportHeadlineLevels :: Int
exportHeadlineLevels = Int
val })
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
"inline"
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
"num"
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"p" (\Bool
val ExportSettings
es -> ExportSettings
es { exportWithPlanning :: Bool
exportWithPlanning = Bool
val })
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
"pri"
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
"prop"
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
"stat"
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"tags" (\Bool
val ExportSettings
es -> ExportSettings
es { exportWithTags :: Bool
exportWithTags = Bool
val })
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
"tasks"
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter TeXExport -> OrgParser m ()
texSetting     Text
"tex" (\TeXExport
val ExportSettings
es -> ExportSettings
es { exportWithLatex :: TeXExport
exportWithLatex = TeXExport
val })
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
"timestamp"
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
"title"
  , forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
"toc"
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"todo" (\Bool
val ExportSettings
es -> ExportSettings
es { exportWithTodoKeywords :: Bool
exportWithTodoKeywords = Bool
val })
  , forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting Text
"|" (\Bool
val ExportSettings
es -> ExportSettings
es { exportWithTables :: Bool
exportWithTables = Bool
val })
  , forall (m :: * -> *). PandocMonad m => OrgParser m ()
ignoreAndWarn
  ] forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"export setting"

-- | Generic handler for export settings. Takes a parser which converts
-- the plain option text into a data structure.
genericExportSetting :: Monad m
                     => OrgParser m a
                     -> Text
                     -> ExportSettingSetter a
                     -> OrgParser m ()
genericExportSetting :: forall (m :: * -> *) a.
Monad m =>
OrgParser m a -> Text -> ExportSettingSetter a -> OrgParser m ()
genericExportSetting OrgParser m a
optionParser Text
settingIdentifier ExportSettingSetter a
setter = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
  Char
_     <- forall s (m :: * -> *) u.
(Stream s m Char, UpdateSourcePos s Char) =>
Text -> ParsecT s u m Text
textStr Text
settingIdentifier forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
Char -> ParsecT s u m Char
char Char
':'
  a
value <- OrgParser m a
optionParser
  forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
updateState forall a b. (a -> b) -> a -> b
$ a -> OrgParserState -> OrgParserState
modifyExportSettings a
value
 where
   modifyExportSettings :: a -> OrgParserState -> OrgParserState
modifyExportSettings a
val OrgParserState
st =
     OrgParserState
st { orgStateExportSettings :: ExportSettings
orgStateExportSettings = ExportSettingSetter a
setter a
val forall b c a. (b -> c) -> (a -> b) -> a -> c
. OrgParserState -> ExportSettings
orgStateExportSettings forall a b. (a -> b) -> a -> b
$ OrgParserState
st }

-- | A boolean option, either nil (False) or non-nil (True).
booleanSetting :: Monad m => Text ->  ExportSettingSetter Bool -> OrgParser m ()
booleanSetting :: forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Bool -> OrgParser m ()
booleanSetting = forall (m :: * -> *) a.
Monad m =>
OrgParser m a -> Text -> ExportSettingSetter a -> OrgParser m ()
genericExportSetting forall (m :: * -> *). Monad m => OrgParser m Bool
elispBoolean

-- | An integer-valued option.
integerSetting :: Monad m => Text -> ExportSettingSetter Int -> OrgParser m ()
integerSetting :: forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter Int -> OrgParser m ()
integerSetting = forall (m :: * -> *) a.
Monad m =>
OrgParser m a -> Text -> ExportSettingSetter a -> OrgParser m ()
genericExportSetting forall {u}. ParsecT Sources u (ReaderT OrgParserLocal m) Int
parseInt
 where
   parseInt :: ParsecT Sources u (ReaderT OrgParserLocal m) Int
parseInt = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$
     forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
ParsecT s u m Char
digit forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe a
listToMaybe forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Read a => ReadS a
reads

-- | Either the string "headline" or an elisp boolean and treated as an
-- @ArchivedTreesOption@.
archivedTreeSetting :: Monad m
                    => Text
                    -> ExportSettingSetter ArchivedTreesOption
                    -> OrgParser m ()
archivedTreeSetting :: forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter ArchivedTreesOption -> OrgParser m ()
archivedTreeSetting =
  forall (m :: * -> *) a.
Monad m =>
OrgParser m a -> Text -> ExportSettingSetter a -> OrgParser m ()
genericExportSetting forall a b. (a -> b) -> a -> b
$ ParsecT
  Sources
  OrgParserState
  (ReaderT OrgParserLocal m)
  ArchivedTreesOption
archivedTreesHeadlineSetting forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT
  Sources
  OrgParserState
  (ReaderT OrgParserLocal m)
  ArchivedTreesOption
archivedTreesBoolean
 where
   archivedTreesHeadlineSetting :: ParsecT
  Sources
  OrgParserState
  (ReaderT OrgParserLocal m)
  ArchivedTreesOption
archivedTreesHeadlineSetting =
     ArchivedTreesOption
ArchivedTreesHeadlineOnly forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). Monad m => Text -> OrgParser m Text
optionString Text
"headline"

   archivedTreesBoolean :: ParsecT
  Sources
  OrgParserState
  (ReaderT OrgParserLocal m)
  ArchivedTreesOption
archivedTreesBoolean = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
     Bool
exportBool <- forall (m :: * -> *). Monad m => OrgParser m Bool
elispBoolean
     forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
       if Bool
exportBool
       then ArchivedTreesOption
ArchivedTreesExport
       else ArchivedTreesOption
ArchivedTreesNoExport

-- | A list or a complement list (i.e. a list starting with `not`).
complementableListSetting :: Monad m
                          => Text
                          -> ExportSettingSetter (Either [Text] [Text])
                          -> OrgParser m ()
complementableListSetting :: forall (m :: * -> *).
Monad m =>
Text
-> ExportSettingSetter (Either [Text] [Text]) -> OrgParser m ()
complementableListSetting = forall (m :: * -> *) a.
Monad m =>
OrgParser m a -> Text -> ExportSettingSetter a -> OrgParser m ()
genericExportSetting forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice
  [ forall a b. a -> Either a b
Left  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). Monad m => OrgParser m [Text]
complementTextList
  , forall a b. b -> Either a b
Right forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). Monad m => OrgParser m [Text]
stringList
  , (\Bool
b -> if Bool
b then forall a b. a -> Either a b
Left [] else forall a b. b -> Either a b
Right []) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). Monad m => OrgParser m Bool
elispBoolean
  ]
 where
   -- Read a plain list of strings.
   stringList :: Monad m => OrgParser m [Text]
   stringList :: forall (m :: * -> *). Monad m => OrgParser m [Text]
stringList = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$
     forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
Char -> ParsecT s u m Char
char Char
'('
       forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy forall (m :: * -> *). Monad m => OrgParser m Text
elispText forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
ParsecT s u m ()
spaces
       forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
Char -> ParsecT s u m Char
char Char
')'

   -- Read an emacs lisp list specifying a complement set.
   complementTextList :: Monad m => OrgParser m [Text]
   complementTextList :: forall (m :: * -> *). Monad m => OrgParser m [Text]
complementTextList = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$
     forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
String -> ParsecT s u m String
string String
"(not "
       forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy forall (m :: * -> *). Monad m => OrgParser m Text
elispText forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
ParsecT s u m ()
spaces
       forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
Char -> ParsecT s u m Char
char Char
')'

   elispText :: Monad m => OrgParser m Text
   elispText :: forall (m :: * -> *). Monad m => OrgParser m Text
elispText = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$
     forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
Char -> ParsecT s u m Char
char Char
'"'
       forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall s (m :: * -> *) t st a.
Stream s m t =>
ParsecT s st m Char -> ParsecT s st m a -> ParsecT s st m Text
manyTillChar forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
ParsecT s u m Char
alphaNum (forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
Char -> ParsecT s u m Char
char Char
'"')

-- | Parses either @t@, @nil@, or @verbatim@ into a 'TeXExport' value.
texSetting :: Monad m
           => Text
           -> ExportSettingSetter TeXExport
           -> OrgParser m ()
texSetting :: forall (m :: * -> *).
Monad m =>
Text -> ExportSettingSetter TeXExport -> OrgParser m ()
texSetting = forall (m :: * -> *) a.
Monad m =>
OrgParser m a -> Text -> ExportSettingSetter a -> OrgParser m ()
genericExportSetting forall a b. (a -> b) -> a -> b
$ ParsecT Sources OrgParserState (ReaderT OrgParserLocal m) TeXExport
texVerbatim forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT Sources OrgParserState (ReaderT OrgParserLocal m) TeXExport
texBoolean
 where
   texVerbatim :: ParsecT Sources OrgParserState (ReaderT OrgParserLocal m) TeXExport
texVerbatim = TeXExport
TeXVerbatim forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (m :: * -> *). Monad m => Text -> OrgParser m Text
optionString Text
"verbatim"

   texBoolean :: ParsecT Sources OrgParserState (ReaderT OrgParserLocal m) TeXExport
texBoolean = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
     Bool
exportBool <- forall (m :: * -> *). Monad m => OrgParser m Bool
elispBoolean
     forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
       if Bool
exportBool
       then TeXExport
TeXExport
       else TeXExport
TeXIgnore

-- | Read but ignore the export setting.
ignoredSetting :: Monad m => Text -> OrgParser m ()
ignoredSetting :: forall (m :: * -> *). Monad m => Text -> OrgParser m ()
ignoredSetting Text
s = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (() forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall s (m :: * -> *) u.
(Stream s m Char, UpdateSourcePos s Char) =>
Text -> ParsecT s u m Text
textStr Text
s forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
Char -> ParsecT s u m Char
char Char
':' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 forall s (m :: * -> *) st.
(Stream s m Char, UpdateSourcePos s Char) =>
ParsecT s st m Char
nonspaceChar)

-- | Read any setting string, but ignore it and emit a warning.
ignoreAndWarn :: PandocMonad m => OrgParser m ()
ignoreAndWarn :: forall (m :: * -> *). PandocMonad m => OrgParser m ()
ignoreAndWarn = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
  Text
opt <- forall s (m :: * -> *) t st.
Stream s m t =>
ParsecT s st m Char -> ParsecT s st m Text
many1Char forall s (m :: * -> *) st.
(Stream s m Char, UpdateSourcePos s Char) =>
ParsecT s st m Char
nonspaceChar
  forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
report (Text -> LogMessage
UnknownOrgExportOption Text
opt)
  forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Read an elisp boolean.  Only NIL is treated as false, non-NIL values are
-- interpreted as true.
elispBoolean :: Monad m => OrgParser m Bool
elispBoolean :: forall (m :: * -> *). Monad m => OrgParser m Bool
elispBoolean = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
  String
value <- forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 forall s (m :: * -> *) st.
(Stream s m Char, UpdateSourcePos s Char) =>
ParsecT s st m Char
nonspaceChar
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ case forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower String
value of
             String
"nil" -> Bool
False
             String
"{}"  -> Bool
False
             String
"()"  -> Bool
False
             String
_     -> Bool
True

-- | Try to parse a literal string as the option value. Returns the
-- string on success.
optionString :: Monad m => Text -> OrgParser m Text
optionString :: forall (m :: * -> *). Monad m => Text -> OrgParser m Text
optionString Text
s = forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try forall a b. (a -> b) -> a -> b
$ do
  String
_ <- forall (m :: * -> *) s u.
(Monad m, Stream s m Char, UpdateSourcePos s Char) =>
String -> ParsecT s u m String
string (Text -> String
unpack Text
s)
  forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
lookAhead (forall (m :: * -> *). Monad m => OrgParser m Char
newline forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> forall s (m :: * -> *) st.
(Stream s m Char, UpdateSourcePos s Char) =>
ParsecT s st m Char
spaceChar)
  forall (m :: * -> *) a. Monad m => a -> m a
return Text
s