-- | Parsers for Org elements.
module Org.Parser.Elements
  ( -- * General
    elements

    -- * Greater elements
  , plainList
  , greaterBlock
  , drawer
  , footnoteDef
  , table

    -- * Lesser elements
  , clock
  , exampleBlock
  , fixedWidth
  , srcBlock
  , exportBlock
  , latexEnvironment
  , keyword
  , horizontalRule
  , commentLine
  , commentBlock
  ) where

import Data.Text qualified as T
import Org.Builder qualified as B
import Org.Parser.Common
import Org.Parser.Definitions
import Org.Parser.MarkupContexts
import Org.Parser.Objects
import Relude.Extra hiding (elems, next)
import Replace.Megaparsec
import Prelude hiding (many, some)

-- * General

-- | Parse zero or more Org elements.
elements :: OrgParser OrgElements
elements :: OrgParser OrgElements
elements = forall a. Monoid a => [a] -> a
mconcat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many OrgParser OrgElements
e
  where
    e :: OrgParser OrgElements
e = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy forall e s (m :: * -> *). MonadParsec e s m => m ()
eof forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Bool -> OrgParser OrgElements
elementIndented Int
0 Bool
False

elementsIndented :: Int -> OrgParser OrgElements
elementsIndented :: Int -> OrgParser OrgElements
elementsIndented Int
minI = forall a. Monoid a => [a] -> a
mconcat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many OrgParser OrgElements
e
  where
    e :: OrgParser OrgElements
e = do
      forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (forall (m :: * -> *). MonadParser m => m ()
blankline' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). MonadParser m => m ()
blankline') forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *). MonadParsec e s m => m ()
eof)
      Int -> Bool -> OrgParser OrgElements
elementIndented Int
minI Bool
False

{- | Each element parser must consume till the start of a line or EOF.
This is necessary for correct counting of list indentations.
-}
elementIndented ::
  Int ->
  Bool ->
  OrgParser OrgElements
elementIndented :: Int -> Bool -> OrgParser OrgElements
elementIndented Int
minI Bool
paraEnd = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try ([(Text, KeywordValue)] -> OrgParser OrgElements
goKws [])
  where
    goKws :: [(Text, KeywordValue)] -> OrgParser OrgElements
goKws [(Text, KeywordValue)]
kws = do
      forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy OrgParser Int
headingStart
      Int
i <- OrgParser Int
spacesOrTabs
      forall {f :: * -> *}.
MonadParsec Void Text f =>
[(Text, KeywordValue)] -> f OrgElements
blank [(Text, KeywordValue)]
kws forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> do
        forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Int
i forall a. Ord a => a -> a -> Bool
>= Int
minI)
        forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional OrgParser (Text, KeywordValue)
affiliatedKeyword forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
          Just (Text, KeywordValue)
akw -> [(Text, KeywordValue)] -> OrgParser OrgElements
goKws ((Text, KeywordValue)
akw forall a. a -> [a] -> [a]
: [(Text, KeywordValue)]
kws) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *) a. Monad m => a -> m a
return ([(Text, KeywordValue)] -> OrgElements
affToKws ((Text, KeywordValue)
akw forall a. a -> [a] -> [a]
: [(Text, KeywordValue)]
kws))
          Maybe (Text, KeywordValue)
Nothing -> forall a. Int -> OrgParser a -> OrgParser a
withIndentLevel Int
i forall a b. (a -> b) -> a -> b
$ [(Text, KeywordValue)] -> OrgParser OrgElements
finalize [(Text, KeywordValue)]
kws

    finalize :: [(Text, KeywordValue)] -> OrgParser OrgElements
finalize [(Text, KeywordValue)]
kws = do
      [(Text, KeywordValue)] -> OrgElementData -> OrgElements
B.element' [(Text, KeywordValue)]
kws forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> OrgParser OrgElementData
nonParaElement forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> do
        forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Bool
not (Bool
paraEnd Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(Text, KeywordValue)]
kws))
        Int -> [(Text, KeywordValue)] -> OrgParser OrgElements
paraIndented Int
minI [(Text, KeywordValue)]
kws

    blank :: [(Text, KeywordValue)] -> f OrgElements
blank [(Text, KeywordValue)]
kws = do
      forall (m :: * -> *). MonadParser m => m ()
blankline' forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> [(Text, KeywordValue)] -> OrgElements
affToKws [(Text, KeywordValue)]
kws

    affToKws :: [(Text, KeywordValue)] -> OrgElements
affToKws [(Text, KeywordValue)]
kws = forall a. Monoid a => [a] -> a
mconcat (OrgElementData -> OrgElements
B.element forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Text -> KeywordValue -> OrgElementData
B.keyword forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Text, KeywordValue)]
kws)

    nonParaElement :: OrgParser OrgElementData
nonParaElement =
      forall (f :: * -> *) (m :: * -> *) a.
(Foldable f, Alternative m) =>
f (m a) -> m a
choice
        [ OrgParser OrgElementData
clock
        , OrgParser OrgElementData
commentLine
        , OrgParser OrgElementData
exampleBlock
        , OrgParser OrgElementData
srcBlock
        , OrgParser OrgElementData
exportBlock
        , OrgParser OrgElementData
commentBlock
        , OrgParser OrgElementData
greaterBlock
        , OrgParser OrgElementData
plainList
        , OrgParser OrgElementData
latexEnvironment
        , OrgParser OrgElementData
drawer
        , OrgParser OrgElementData
fixedWidth
        , OrgParser OrgElementData
keyword
        , OrgParser OrgElementData
horizontalRule
        , OrgParser OrgElementData
table
        , OrgParser OrgElementData
footnoteDef
        ]

paraIndented :: Int -> [(Text, KeywordValue)] -> OrgParser OrgElements
paraIndented :: Int -> [(Text, KeywordValue)] -> OrgParser OrgElements
paraIndented Int
minI [(Text, KeywordValue)]
kws =
  forall (m :: * -> *). MonadParser m => m ()
blankline' forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> forall a. Monoid a => a
mempty forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> do
    (OrgObjects
inls, OrgElements
next) <- forall a end skip.
OrgParser skip
-> OrgParser end -> OrgParser a -> OrgParser (a, end)
withContext_ OrgParser (Tokens Text)
skip OrgParser OrgElements
end (Marked OrgParser OrgObjects -> OrgParser OrgObjects
plainMarkupContext Marked OrgParser OrgObjects
standardSet)
    forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [(Text, KeywordValue)] -> OrgElementData -> OrgElements
B.element' [(Text, KeywordValue)]
kws (OrgObjects -> OrgElementData
B.para OrgObjects
inls) forall a. Semigroup a => a -> a -> a
<> OrgElements
next
  where
    skip :: OrgParser (Tokens Text)
skip = forall e s (m :: * -> *). MonadParsec e s m => m (Token s)
anySingle forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
takeWhileP forall a. Maybe a
Nothing (forall a. Eq a => a -> a -> Bool
/= Char
'\n')
    end :: OrgParser OrgElements
    end :: OrgParser OrgElements
end =
      (forall e s (m :: * -> *). MonadParsec e s m => m ()
eof forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> forall a. Monoid a => a
mempty) forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
        Token Text
_ <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
newline
        forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead forall (m :: * -> *). MonadParser m => m ()
blankline' forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> forall a. Monoid a => a
mempty
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Bool -> OrgParser OrgElements
elementIndented Int
minI Bool
True
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead OrgParser Int
headingStart forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> forall a. Monoid a => a
mempty
          -- rest of line can't be blank, otherwise elementIndented would succeed
          forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *). Alternative f => Bool -> f ()
guard forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Ord a => a -> a -> Bool
< Int
minI) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< OrgParser Int
spacesOrTabs) forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> forall a. Monoid a => a
mempty
{-# INLINEABLE paraIndented #-}

-- traceWithPos :: String -> OrgParser ()
-- traceWithPos m = do
--   s <- getParserState
--   let
--     err :: ParseError Text Void = FancyError (stateOffset s) (one $ ErrorFail m)
--     bundle = ParseErrorBundle (err :| []) (statePosState s)
--   traceM $ errorBundlePretty bundle

-- * Greater elements

-- ** Lists

-- | Parse a plain list.
plainList :: OrgParser OrgElementData
plainList :: OrgParser OrgElementData
plainList = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  ListItem
fstItem <- OrgParser ListItem
listItem
  [ListItem]
rest <- forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many OrgParser ListItem
itemIndented
  let kind :: ListType
kind = ListItem -> ListType
listItemType ListItem
fstItem
      items :: [ListItem]
items = ListItem
fstItem forall a. a -> [a] -> [a]
: [ListItem]
rest
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ ListType -> [ListItem] -> OrgElementData
B.list ListType
kind [ListItem]
items
  where
    itemIndented :: OrgParser ListItem
itemIndented = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
      forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy OrgParser Int
headingStart
      Int
i <- forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks OrgParserEnv -> Int
orgEnvIndentLevel
      Int
j <- OrgParser Int
spacesOrTabs
      forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Int
j forall a. Eq a => a -> a -> Bool
== Int
i)
      OrgParser ListItem
listItem

listItem :: OrgParser ListItem
listItem :: OrgParser ListItem
listItem = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Int
indent <- forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks OrgParserEnv -> Int
orgEnvIndentLevel
  Bullet
bullet <- OrgParser Bullet
unorderedBullet forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> OrgParser Bullet
counterBullet
  forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1 forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead forall (m :: * -> *). MonadParser m => m ()
newline'
  Maybe Int
cookie <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional OrgParser Int
counterSet
  Maybe Checkbox
box <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional OrgParser Checkbox
checkbox
  -- for the tag, previous horizontal space must have been consumed
  [OrgObject]
tag <- case Bullet
bullet of
    Bullet Char
_ -> forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option [] (forall (t :: * -> *) a. Foldable t => t a -> [a]
toList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> OrgParser OrgObjects
itemTag)
    Bullet
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return []
  OrgElements
els <- forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 forall a. Semigroup a => a -> a -> a
(<>) (Int -> [(Text, KeywordValue)] -> OrgParser OrgElements
paraIndented (Int
indent forall a. Num a => a -> a -> a
+ Int
1) []) (Int -> OrgParser OrgElements
elementsIndented (Int
indent forall a. Num a => a -> a -> a
+ Int
1))
  forall (m :: * -> *) a. Monad m => a -> m a
return (Bullet
-> Maybe Int
-> Maybe Checkbox
-> [OrgObject]
-> [OrgElement]
-> ListItem
ListItem Bullet
bullet Maybe Int
cookie Maybe Checkbox
box [OrgObject]
tag (forall (t :: * -> *) a. Foldable t => t a -> [a]
toList OrgElements
els))
  where
    unorderedBullet :: OrgParser Bullet
unorderedBullet = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ Char -> Bullet
Bullet forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy \Token Text
c -> Token Text
c forall a. Eq a => a -> a -> Bool
== Char
'+' Bool -> Bool -> Bool
|| Token Text
c forall a. Eq a => a -> a -> Bool
== Char
'-' Bool -> Bool -> Bool
|| Token Text
c forall a. Eq a => a -> a -> Bool
== Char
'*'
    counterBullet :: OrgParser Bullet
counterBullet = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
      Text
counter <- forall (m :: * -> *). MonadParser m => m Text
digits1 forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Char -> Text
T.singleton forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy Char -> Bool
isAsciiAlpha
      Char
d <- forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy \Token Text
c -> Token Text
c forall a. Eq a => a -> a -> Bool
== Char
'.' Bool -> Bool -> Bool
|| Token Text
c forall a. Eq a => a -> a -> Bool
== Char
')'
      forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> Char -> Bullet
Counter Text
counter Char
d)

counterSet :: OrgParser Int
counterSet :: OrgParser Int
counterSet =
  forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$
    forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[@"
      forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> OrgParser Int
parseNum
      forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
']'
      forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace
  where
    parseNum :: OrgParser Int
parseNum = forall (m :: * -> *). MonadParser m => m Int
integer forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *). MonadParser m => m Int
asciiAlpha'

checkbox :: OrgParser Checkbox
checkbox :: OrgParser Checkbox
checkbox =
  forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$
    forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'['
      forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> OrgParser Checkbox
tick
      forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
']'
      forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1 forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead forall (m :: * -> *). MonadParser m => m ()
newline')
  where
    tick :: OrgParser Checkbox
tick =
      forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
' ' forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Bool -> Checkbox
BoolBox Bool
False
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'X' forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Bool -> Checkbox
BoolBox Bool
True
        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'-' forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Checkbox
PartialBox

itemTag :: OrgParser OrgObjects
itemTag :: OrgParser OrgObjects
itemTag = forall a b.
(Char -> Bool)
-> (Char -> Bool) -> OrgParser b -> OrgParser a -> OrgParser a
withMContext (forall a. Eq a => a -> a -> Bool
/= Char
'\n') (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
isSpace) OrgParser ()
end (Marked OrgParser OrgObjects -> OrgParser OrgObjects
plainMarkupContext Marked OrgParser OrgObjects
standardSet)
  where
    end :: OrgParser ()
end = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
      forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1
      Tokens Text
_ <- forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"::"
      forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1 forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead forall (m :: * -> *). MonadParser m => m ()
newline'

-- ** Greater blocks

-- | Parse a greater block.
greaterBlock :: OrgParser OrgElementData
greaterBlock :: OrgParser OrgElementData
greaterBlock = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Text
_ <- forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
"#+begin_"
  Text
bname <- OrgParser Text
someNonSpace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine
  OrgElements
els <- forall a end skip.
OrgParser skip -> OrgParser end -> OrgParser a -> OrgParser a
withContext forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine (Text -> OrgParser Text
end Text
bname) OrgParser OrgElements
elements
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ GreaterBlockType -> OrgElements -> OrgElementData
B.greaterBlock (Text -> GreaterBlockType
blockType Text
bname) OrgElements
els
  where
    blockType :: Text -> GreaterBlockType
blockType = \case
      (Text -> Text
T.toLower -> Text
"center") -> GreaterBlockType
Center
      (Text -> Text
T.toLower -> Text
"quote") -> GreaterBlockType
Quote
      Text
other -> Text -> GreaterBlockType
Special Text
other
    end :: Text -> OrgParser Text
    end :: Text -> OrgParser Text
end Text
name = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
"#+end_" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
name forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). MonadParser m => m ()
blankline'

-- verseBlock :: OrgParser OrgElements
-- verseBlock = try do
--   hspace
--   _ <- string'' "#+begin_verse"
--   undefined
--   where
-- end = try $ hspace *> string'' "#+end_export" <* blankline'

-- ** Drawers

-- | Parse a drawer.
drawer :: OrgParser OrgElementData
drawer :: OrgParser OrgElementData
drawer = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Token Text
_ <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
':'
  Text
dname <- forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
takeWhile1P (forall a. a -> Maybe a
Just String
"drawer name") (\Token Text
c -> Token Text
c forall a. Eq a => a -> a -> Bool
/= Char
':' Bool -> Bool -> Bool
&& Token Text
c forall a. Eq a => a -> a -> Bool
/= Char
'\n')
  forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
':' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). MonadParser m => m ()
blankline
  OrgElements
els <- forall a end skip.
OrgParser skip -> OrgParser end -> OrgParser a -> OrgParser a
withContext forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine OrgParser ()
end OrgParser OrgElements
elements
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> OrgElements -> OrgElementData
B.drawer Text
dname OrgElements
els
  where
    end :: OrgParser ()
    end :: OrgParser ()
end = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
":end:" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). MonadParser m => m ()
blankline'

-- ** Footnote definitions

-- | Parse a footnote definition.
footnoteDef :: OrgParser OrgElementData
footnoteDef :: OrgParser OrgElementData
footnoteDef = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  forall (f :: * -> *). Alternative f => Bool -> f ()
guard forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Eq a => a -> a -> Bool
== Int
0) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
asks OrgParserEnv -> Int
orgEnvIndentLevel
  Text
lbl <- OrgParser (Tokens Text)
start
  Maybe ()
_ <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall (m :: * -> *). MonadParser m => m ()
blankline'
  OrgElements
def <-
    forall a end skip.
OrgParser skip -> OrgParser end -> OrgParser a -> OrgParser a
withContext
      forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine
      ( forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead forall a b. (a -> b) -> a -> b
$
          forall (f :: * -> *) a. Functor f => f a -> f ()
void OrgParser Int
headingStart
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try (forall (m :: * -> *). MonadParser m => m ()
blankline' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). MonadParser m => m ()
blankline')
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (f :: * -> *) a. Functor f => f a -> f ()
void (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try OrgParser (Tokens Text)
start)
      )
      OrgParser OrgElements
elements
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> OrgElements -> OrgElementData
B.footnoteDef Text
lbl OrgElements
def
  where
    start :: OrgParser (Tokens Text)
start =
      forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"[fn:"
        forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
takeWhile1P
          (forall a. a -> Maybe a
Just String
"footnote def label")
          (\Token Text
c -> Char -> Bool
isAlphaNum Token Text
c Bool -> Bool -> Bool
|| Token Text
c forall a. Eq a => a -> a -> Bool
== Char
'-' Bool -> Bool -> Bool
|| Token Text
c forall a. Eq a => a -> a -> Bool
== Char
'_')
        forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
']'

-- ** Tables

-- | Parse a table.
table :: OrgParser OrgElementData
table :: OrgParser OrgElementData
table = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Token Text
_ <- forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'|'
  [TableRow]
rows <- forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some OrgParser TableRow
tableRow
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [TableRow] -> OrgElementData
B.table [TableRow]
rows
  where
    tableRow :: OrgParser TableRow
    tableRow :: OrgParser TableRow
tableRow = OrgParser TableRow
ruleRow forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> OrgParser TableRow
columnPropRow forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> OrgParser TableRow
standardRow

    ruleRow :: OrgParser TableRow
ruleRow = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ TableRow
RuleRow forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"|-" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine')

    columnPropRow :: OrgParser TableRow
columnPropRow = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
      forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace
      Token Text
_ <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'|'
      [Maybe ColumnAlignment] -> TableRow
ColumnPropsRow
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some OrgParser (Maybe ColumnAlignment)
cell
        forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). MonadParser m => m ()
blankline'
      where
        cell :: OrgParser (Maybe ColumnAlignment)
cell = do
          forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace
          forall a. a -> Maybe a
Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> OrgParser ColumnAlignment
cookie forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. Maybe a
Nothing forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ forall (f :: * -> *) a. Functor f => f a -> f ()
void (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'|')
        cookie :: OrgParser ColumnAlignment
cookie = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
          ColumnAlignment
a <-
            forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"<l" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ColumnAlignment
AlignLeft
              forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"<c" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ColumnAlignment
AlignCenter
              forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"<r" forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> ColumnAlignment
AlignRight
          Text
_ <- forall (m :: * -> *). MonadParser m => m Text
digits
          Token Text
_ <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'>'
          forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace
          forall (f :: * -> *) a. Functor f => f a -> f ()
void (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'|') forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead forall (m :: * -> *). MonadParser m => m ()
newline'
          forall (f :: * -> *) a. Applicative f => a -> f a
pure ColumnAlignment
a

    standardRow :: OrgParser TableRow
standardRow = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
      forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace
      Token Text
_ <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'|'
      [OrgObjects] -> TableRow
B.standardRow
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some OrgParser OrgObjects
cell
        forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). MonadParser m => m ()
blankline'
      where
        cell :: OrgParser OrgObjects
cell = do
          forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace
          forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'|' forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> forall a. Monoid a => a
mempty
            forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a b.
(Char -> Bool)
-> (Char -> Bool) -> OrgParser b -> OrgParser a -> OrgParser a
withMContext
              (forall a b. a -> b -> a
const Bool
True)
              (\Char
c -> Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ Char -> Bool
isSpace Char
c Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'|')
              OrgParser ()
end
              (Marked OrgParser OrgObjects -> OrgParser OrgObjects
plainMarkupContext Marked OrgParser OrgObjects
standardSet)
        end :: OrgParser ()
end = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (f :: * -> *) a. Functor f => f a -> f ()
void (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'|') forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead forall (m :: * -> *). MonadParser m => m ()
newline'

-- * Lesser elements

-- ** Code

-- | Parse an example block.
exampleBlock :: OrgParser OrgElementData
exampleBlock :: OrgParser OrgElementData
exampleBlock = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Text
_ <- forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
"#+begin_example"
  Map Text Text
switches <- OrgParser (Map Text Text)
blockSwitches
  Text
_ <- forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine
  [SrcLine]
contents <- forall void. OrgParser void -> Map Text Text -> OrgParser [SrcLine]
rawBlockContents OrgParser Text
end Map Text Text
switches
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Map Text Text -> [SrcLine] -> OrgElementData
B.example Map Text Text
switches [SrcLine]
contents
  where
    end :: OrgParser Text
end = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
"#+end_example" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). MonadParser m => m ()
blankline'

-- | Parse a fixed width block.
fixedWidth :: OrgParser OrgElementData
fixedWidth :: OrgParser OrgElementData
fixedWidth = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  [SrcLine]
contents <- Text -> SrcLine
SrcLine forall (f :: * -> *) (g :: * -> *) a b.
(Functor f, Functor g) =>
(a -> b) -> f (g a) -> f (g b)
<<$>> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
some (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
": " forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine')
  Int
tabWidth <- forall a. (OrgOptions -> a) -> OrgParser a
getsO OrgOptions -> Int
orgSrcTabWidth
  Bool
preserveIndent <- forall a. (OrgOptions -> a) -> OrgParser a
getsO OrgOptions -> Bool
orgSrcPreserveIndentation
  let lines' :: [SrcLine]
lines' =
        if Bool
preserveIndent
          then forall a b. (a -> b) -> [a] -> [b]
map ((Text -> Text) -> SrcLine -> SrcLine
srcLineMap (Int -> Text -> Text
tabsToSpaces Int
tabWidth)) [SrcLine]
contents
          else Int -> [SrcLine] -> [SrcLine]
indentContents Int
tabWidth [SrcLine]
contents
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Map Text Text -> [SrcLine] -> OrgElementData
B.example forall a. Monoid a => a
mempty [SrcLine]
lines'

-- | Parse a source block.
srcBlock :: OrgParser OrgElementData
srcBlock :: OrgParser OrgElementData
srcBlock = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Text
_ <- forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
"#+begin_src"
  Text
lang <- forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Text
"" forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> OrgParser Text
someNonSpace
  Map Text Text
switches <- OrgParser (Map Text Text)
blockSwitches
  [(Text, Text)]
args <- OrgParser [(Text, Text)]
headerArgs
  [SrcLine]
contents <- forall void. OrgParser void -> Map Text Text -> OrgParser [SrcLine]
rawBlockContents OrgParser Text
end Map Text Text
switches
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text
-> Map Text Text -> [(Text, Text)] -> [SrcLine] -> OrgElementData
B.srcBlock Text
lang Map Text Text
switches [(Text, Text)]
args [SrcLine]
contents
  where
    end :: OrgParser Text
end = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
"#+end_src" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). MonadParser m => m ()
blankline'

headerArgs :: OrgParser [(Text, Text)]
headerArgs :: OrgParser [(Text, Text)]
headerArgs = do
  forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace
  forall l. IsList l => [Item l] -> l
fromList
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> OrgParser (Text, Text)
headerArg
    forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
`sepBy` forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine'
  where
    headerArg :: OrgParser (Text, Text)
headerArg =
      forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2
        (,)
        (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
':' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> OrgParser Text
someNonSpace)
        ( Text -> Text
T.strip forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall end.
(Char -> Bool) -> OrgParser end -> OrgParser (Text, end)
findSkipping
              (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
isSpace)
              ( forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$
                  forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead
                    ( forall (m :: * -> *). MonadParser m => m ()
newline'
                        forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
':'
                    )
              )
        )

-- | Parse an export block.
exportBlock :: OrgParser OrgElementData
exportBlock :: OrgParser OrgElementData
exportBlock = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Text
_ <- forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
"#+begin_export"
  Text
format <- forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Text
"" forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> OrgParser Text
someNonSpace
  Text
_ <- forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine
  Text
contents <- [Text] -> Text
T.unlines forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
manyTill forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine OrgParser Text
end
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> Text -> OrgElementData
B.export Text
format Text
contents
  where
    end :: OrgParser Text
end = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
"#+end_export" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). MonadParser m => m ()
blankline'

indentContents :: Int -> [SrcLine] -> [SrcLine]
indentContents :: Int -> [SrcLine] -> [SrcLine]
indentContents Int
tabWidth (forall a b. (a -> b) -> [a] -> [b]
map ((Text -> Text) -> SrcLine -> SrcLine
srcLineMap forall a b. (a -> b) -> a -> b
$ Int -> Text -> Text
tabsToSpaces Int
tabWidth) -> [SrcLine]
lins) =
  forall a b. (a -> b) -> [a] -> [b]
map ((Text -> Text) -> SrcLine -> SrcLine
srcLineMap forall a b. (a -> b) -> a -> b
$ Int -> Text -> Text
T.drop Int
minIndent) [SrcLine]
lins
  where
    minIndent :: Int
minIndent = forall b a. b -> (a -> b) -> Maybe a -> b
maybe Int
0 forall (f :: * -> *) a. (Foldable1 f, Ord a) => f a -> a
minimum1 (forall a. [a] -> Maybe (NonEmpty a)
nonEmpty forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (Text -> Int
indentSize forall b c a. (b -> c) -> (a -> b) -> a -> c
. SrcLine -> Text
srcLineContent) [SrcLine]
lins)
    indentSize :: Text -> Int
indentSize = Text -> Int
T.length forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> Text -> Text
T.takeWhile (forall a. Eq a => a -> a -> Bool
== Char
' ')

tabsToSpaces :: Int -> Text -> Text
tabsToSpaces :: Int -> Text -> Text
tabsToSpaces Int
tabWidth Text
txt =
  (Char -> Bool) -> Text -> (Text, Text)
T.span (\Char
c -> Char
c forall a. Eq a => a -> a -> Bool
== Char
' ' Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'\t') Text
txt
    forall a b. a -> (a -> b) -> b
& forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first
      ( forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> Text -> Text
T.replicate Text
" "
          forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall a. Num a => a -> a -> a
(+)
          forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap Text -> Int
T.length ((forall a. Num a => a -> a -> a
* Int
tabWidth) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Int
T.length)
          forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> Text -> (Text, Text)
T.partition (forall a. Eq a => a -> a -> Bool
== Char
' ')
      )
    forall a b. a -> (a -> b) -> b
& forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry forall a. Semigroup a => a -> a -> a
(<>)

rawBlockContents :: OrgParser void -> Map Text Text -> OrgParser [SrcLine]
rawBlockContents :: forall void. OrgParser void -> Map Text Text -> OrgParser [SrcLine]
rawBlockContents OrgParser void
end Map Text Text
switches = do
  [SrcLine]
contents <- forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
manyTill (Map Text Text -> OrgParser SrcLine
rawBlockLine Map Text Text
switches) OrgParser void
end
  Int
tabWidth <- forall a. (OrgOptions -> a) -> OrgParser a
getsO OrgOptions -> Int
orgSrcTabWidth
  Bool
preserveIndent <- forall a. (OrgOptions -> a) -> OrgParser a
getsO OrgOptions -> Bool
orgSrcPreserveIndentation
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$
    if Bool
preserveIndent Bool -> Bool -> Bool
|| Text
"-i" forall t. StaticMap t => Key t -> t -> Bool
`member` Map Text Text
switches
      then forall a b. (a -> b) -> [a] -> [b]
map ((Text -> Text) -> SrcLine -> SrcLine
srcLineMap (Int -> Text -> Text
tabsToSpaces Int
tabWidth)) [SrcLine]
contents
      else Int -> [SrcLine] -> [SrcLine]
indentContents Int
tabWidth [SrcLine]
contents

quotedLine :: OrgParser Text
quotedLine :: OrgParser Text
quotedLine = do
  forall a. Semigroup a => a -> a -> a
(<>)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Text
"" (forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
',' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"*" forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"#+"))
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine

rawBlockLine :: Map Text Text -> OrgParser SrcLine
rawBlockLine :: Map Text Text -> OrgParser SrcLine
rawBlockLine Map Text Text
switches =
  forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ forall {f :: * -> *}. Applicative f => Text -> f SrcLine
applyRef forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< OrgParser Text
quotedLine
  where
    (Text
refpre, Text
refpos) =
      forall b a. b -> (a -> b) -> Maybe a -> b
maybe
        (Text
"(ref:", Text
")")
        (forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second (Int -> Text -> Text
T.drop Int
2) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text -> (Text, Text)
T.breakOn Text
"%s")
        forall a b. (a -> b) -> a -> b
$ forall t. StaticMap t => Key t -> t -> Maybe (Val t)
lookup Text
"-l" Map Text Text
switches
    applyRef :: Text -> f SrcLine
applyRef Text
txt
      | Just (Text
content, Text
ref, Text
_) <- forall e s a.
(Ord e, Stream s, Tokens s ~ s) =>
Parsec e s a -> s -> Maybe (s, a, s)
breakCap Parser Text
refCookie Text
txt =
          forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Text -> Text -> SrcLine
RefLine Text
"" Text
ref Text
content
      | Bool
otherwise = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> SrcLine
SrcLine Text
txt
    refCookie :: Parser Text
    refCookie :: Parser Text
refCookie = do
      forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
space1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Text
refpre
      forall a. ToText a => a -> Text
toText
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a sep. MonadPlus m => m a -> m sep -> m [a]
someTill
          (forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy forall a b. (a -> b) -> a -> b
$ \Token Text
c -> Char -> Bool
isAsciiAlpha Token Text
c Bool -> Bool -> Bool
|| Char -> Bool
isDigit Token Text
c Bool -> Bool -> Bool
|| Token Text
c forall a. Eq a => a -> a -> Bool
== Char
'-' Bool -> Bool -> Bool
|| Token Text
c forall a. Eq a => a -> a -> Bool
== Char
' ')
          (forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Text
refpos)

blockSwitches :: OrgParser (Map Text Text)
blockSwitches :: OrgParser (Map Text Text)
blockSwitches = forall l. IsList l => [Item l] -> l
fromList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many (OrgParser (Text, Text)
linum forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> OrgParser (Text, Text)
switch forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> OrgParser (Text, Text)
fmt)
  where
    linum :: OrgParser (Text, Text)
    linum :: OrgParser (Text, Text)
linum = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ do
      forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1
      Text
s <-
        Text -> Char -> Text
T.snoc forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x. One x => OneItem x -> x
one
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) e s (m :: * -> *).
(Foldable f, MonadParsec e s m) =>
f (Token s) -> m (Token s)
oneOf [Char
'+', Char
'-']
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'n'
      Text
num <- forall (m :: * -> *) a. Alternative m => a -> m a -> m a
option Text
"" forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1 forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
takeWhileP forall a. Maybe a
Nothing Char -> Bool
isDigit
      Token Text
_ <- forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
spaceChar
      forall (m :: * -> *) a. Monad m => a -> m a
return (Text
s, Text
num)

    fmt :: OrgParser (Text, Text)
    fmt :: OrgParser (Text, Text)
fmt = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ do
      forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1
      Text
s <- forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"-l"
      forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1
      Text
str <-
        forall (m :: * -> *) open close a.
Applicative m =>
m open -> m close -> m a -> m a
between (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'"') (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'"') forall a b. (a -> b) -> a -> b
$
          forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
takeWhileP forall a. Maybe a
Nothing (\Token Text
c -> Token Text
c forall a. Eq a => a -> a -> Bool
/= Char
'"' Bool -> Bool -> Bool
&& Token Text
c forall a. Eq a => a -> a -> Bool
/= Char
'\n')
      Token Text
_ <- forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
spaceChar
      forall (m :: * -> *) a. Monad m => a -> m a
return (Text
s, Text
str)

    switch :: OrgParser (Text, Text)
    switch :: OrgParser (Text, Text)
switch = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ do
      forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1
      Text
s <-
        Text -> Char -> Text
T.snoc forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x. One x => OneItem x -> x
one
          forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'-'
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) e s (m :: * -> *).
(Foldable f, MonadParsec e s m) =>
f (Token s) -> m (Token s)
oneOf [Char
'i', Char
'k', Char
'r']
      Token Text
_ <- forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
lookAhead forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m (Token s)
spaceChar
      forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text
s, Text
"")

-- ** LaTeX

-- | Parse a LaTeX environment.
latexEnvironment :: OrgParser OrgElementData
latexEnvironment :: OrgParser OrgElementData
latexEnvironment = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Tokens Text
_ <- forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"\\begin{"
  Text
ename <-
    forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
takeWhile1P
      (forall a. a -> Maybe a
Just String
"latex environment name")
      (\Token Text
c -> Char -> Bool
isAsciiAlpha Token Text
c Bool -> Bool -> Bool
|| Char -> Bool
isDigit Token Text
c Bool -> Bool -> Bool
|| Token Text
c forall a. Eq a => a -> a -> Bool
== Char
'*')
  Token Text
_ <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'}'
  (Text
str, ()
_) <- forall end.
(Char -> Bool) -> OrgParser end -> OrgParser (Text, end)
findSkipping (forall a. Eq a => a -> a -> Bool
/= Char
'\\') (Text -> OrgParser ()
end Text
ename)
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> Text -> OrgElementData
B.latexEnvironment Text
ename forall a b. (a -> b) -> a -> b
$ Text
"\\begin{" forall a. Semigroup a => a -> a -> a
<> Text
ename forall a. Semigroup a => a -> a -> a
<> Text
"}" forall a. Semigroup a => a -> a -> a
<> Text
str forall a. Semigroup a => a -> a -> a
<> Text
"\\end{" forall a. Semigroup a => a -> a -> a
<> Text
ename forall a. Semigroup a => a -> a -> a
<> Text
"}"
  where
    end :: Text -> OrgParser ()
    end :: Text -> OrgParser ()
end Text
name = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string (Text
"\\end{" forall a. Semigroup a => a -> a -> a
<> Text
name forall a. Semigroup a => a -> a -> a
<> Text
"}") forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). MonadParser m => m ()
blankline'

-- ** Keywords

affiliatedKeyword :: OrgParser (Text, KeywordValue)
affiliatedKeyword :: OrgParser (Text, KeywordValue)
affiliatedKeyword = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  (Text, KeywordValue)
v <- OrgParser (Text, KeywordValue)
keywordData
  let name :: Text
name = forall a b. (a, b) -> a
fst (Text, KeywordValue)
v
  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Text
"attr_" Text -> Text -> Bool
`T.isPrefixOf` Text
name) do
    Set Text
akws <- forall a. (OrgOptions -> a) -> OrgParser a
getsO OrgOptions -> Set Text
orgElementAffiliatedKeywords
    forall (f :: * -> *). Alternative f => Bool -> f ()
guard forall a b. (a -> b) -> a -> b
$ Text
name forall t. StaticMap t => Key t -> t -> Bool
`member` Set Text
akws
  forall (m :: * -> *) a. Monad m => a -> m a
return (Text, KeywordValue)
v

-- | Parse a keyword.
keyword :: OrgParser OrgElementData
keyword :: OrgParser OrgElementData
keyword = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Text -> KeywordValue -> OrgElementData
B.keyword forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> OrgParser (Text, KeywordValue)
keywordData

keywordData :: OrgParser (Text, KeywordValue)
keywordData :: OrgParser (Text, KeywordValue)
keywordData = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Tokens Text
_ <- forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"#+"
  -- This is one of the places where it is convoluted to replicate org-element
  -- regexes: "#+abc:d:e :f" is a valid keyword of key "abc:d" and value "e :f".
  Text
name <-
    Text -> Text
T.toLower forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. (a -> a) -> a
fix \OrgParser (Text, ())
me -> do
      res :: (Text, ())
res@(Text
name, ()
_) <-
        forall skip end (m :: * -> *).
MonadParser m =>
m skip -> m end -> m (Text, end)
skipManyTill' (forall e s (m :: * -> *).
MonadParsec e s m =>
(Token s -> Bool) -> m (Token s)
satisfy (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
isSpace)) forall a b. (a -> b) -> a -> b
$
          forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$
            forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
':' forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m ()
notFollowedBy OrgParser (Text, ())
me
      forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ Text -> Bool
T.null Text
name)
      forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text, ())
res
  forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace
  if Text
"attr_" Text -> Text -> Bool
`T.isPrefixOf` Text
name
    then do
      KeywordValue
args <- [(Text, Text)] -> KeywordValue
B.attrKeyword forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> OrgParser [(Text, Text)]
headerArgs
      forall (m :: * -> *) a. Monad m => a -> m a
return (Text
name, KeywordValue
args)
    else do
      Text
text <- Text -> Text
T.stripEnd forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine'
      Set Text
parsedKws <- forall a. (OrgOptions -> a) -> OrgParser a
getsO OrgOptions -> Set Text
orgElementParsedKeywords
      KeywordValue
value <-
        if Text
name forall t. StaticMap t => Key t -> t -> Bool
`member` Set Text
parsedKws
          then do
            FullState
st <- OrgParser FullState
getFullState
            [OrgObject] -> KeywordValue
ParsedKeyword forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> [a]
toList
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall b. FullState -> Text -> OrgParser b -> OrgParser b
parseFromText FullState
st Text
text (Marked OrgParser OrgObjects -> OrgParser OrgObjects
plainMarkupContext Marked OrgParser OrgObjects
standardSet)
          else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Text -> KeywordValue
ValueKeyword Text
text
      forall (m :: * -> *) a. Monad m => a -> m a
return (Text
name, KeywordValue
value)

-- ** Horizontal Rules

-- | Parse a horizontal rule.
horizontalRule :: OrgParser OrgElementData
horizontalRule :: OrgParser OrgElementData
horizontalRule = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Int
l <- Text -> Int
T.length forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e s (m :: * -> *).
MonadParsec e s m =>
Maybe String -> (Token s -> Bool) -> m (Tokens s)
takeWhile1P (forall a. a -> Maybe a
Just String
"hrule dashes") (forall a. Eq a => a -> a -> Bool
== Char
'-')
  forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Int
l forall a. Ord a => a -> a -> Bool
>= Int
5)
  forall (m :: * -> *). MonadParser m => m ()
blankline'
  forall (m :: * -> *) a. Monad m => a -> m a
return OrgElementData
B.horizontalRule

-- ** Comments

-- | Parse a comment.
commentLine :: OrgParser OrgElementData
commentLine :: OrgParser OrgElementData
commentLine = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Token Text
_ <- forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
'#'
  forall (m :: * -> *). MonadParser m => m ()
blankline' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
Token s -> m (Token s)
char Char
' ' forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"If this was meant as a comment, a space is missing here.") forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (f :: * -> *) a. Functor f => f a -> f ()
void forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine'
  forall (f :: * -> *) a. Applicative f => a -> f a
pure OrgElementData
Comment

-- | Parse a comment block.
commentBlock :: OrgParser OrgElementData
commentBlock :: OrgParser OrgElementData
commentBlock = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Text
_ <- forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
"#+begin_comment"
  Text
_ <- forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine
  Text
_ <- forall (m :: * -> *) a end. MonadPlus m => m a -> m end -> m end
skipManyTill forall (m :: * -> *). MonadParser m => m (Tokens Text)
anyLine OrgParser Text
end
  forall (f :: * -> *) a. Applicative f => a -> f a
pure OrgElementData
Comment
  where
    end :: OrgParser Text
end = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
"#+end_comment" forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* forall (m :: * -> *). MonadParser m => m ()
blankline'

clock :: OrgParser OrgElementData
clock :: OrgParser OrgElementData
clock = forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try do
  Text
_ <- forall (m :: * -> *). MonadParser m => Text -> m Text
string'' Text
"clock: "
  TimestampData
ts <- OrgParser TimestampData
parseTimestamp
  case TimestampData
ts of
    TimestampData Bool
False DateTime
_ -> do
      forall (m :: * -> *). MonadParser m => m ()
blankline'
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ TimestampData -> Maybe (Int, Int) -> OrgElementData
B.clock TimestampData
ts forall a. Maybe a
Nothing
    TimestampRange Bool
False DateTime
_ DateTime
_ -> do
      Maybe (Int, Int)
t <- forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional forall a b. (a -> b) -> a -> b
$ do
        Tokens Text
_ <- forall e s (m :: * -> *) a. MonadParsec e s m => m a -> m a
try forall a b. (a -> b) -> a -> b
$ do
          forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1
          forall e s (m :: * -> *).
MonadParsec e s m =>
Tokens s -> m (Tokens s)
string Tokens Text
"=>"
        forall e s (m :: * -> *).
(MonadParsec e s m, Token s ~ Char) =>
m ()
hspace1
        OrgParser (Int, Int)
parseTime
      forall (m :: * -> *). MonadParser m => m ()
blankline'
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ TimestampData -> Maybe (Int, Int) -> OrgElementData
B.clock TimestampData
ts Maybe (Int, Int)
t
    TimestampData
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Clock timestamp must be inactive."