module Hakyllbars.Source.Util where

import Control.Monad (when)
import Control.Monad.Identity hiding (when)
import Data.Default
import Text.Parsec hiding (label, runParser, token, (<?>))
import qualified Text.Parsec as P

data ParserState = ParserState
  { ParserState -> LexerMode
parserStateLexerMode :: LexerMode,
    ParserState -> Bool
parserStateIsDebugging :: Bool
  }

instance Default ParserState where
  def :: ParserState
def =
    ParserState
      { parserStateLexerMode :: LexerMode
parserStateLexerMode = LexerMode
TextMode,
        parserStateIsDebugging :: Bool
parserStateIsDebugging = Bool
False
      }

data LexerMode
  = TextMode
  | BlockMode
  | FencedMode Int
  deriving (Int -> LexerMode -> ShowS
[LexerMode] -> ShowS
LexerMode -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LexerMode] -> ShowS
$cshowList :: [LexerMode] -> ShowS
show :: LexerMode -> String
$cshow :: LexerMode -> String
showsPrec :: Int -> LexerMode -> ShowS
$cshowsPrec :: Int -> LexerMode -> ShowS
Show)

runParser :: (Stream s Identity t) => Parsec s ParserState a -> SourceName -> s -> Either ParseError a
runParser :: forall s t a.
Stream s Identity t =>
Parsec s ParserState a -> String -> s -> Either ParseError a
runParser = forall s t a.
Stream s Identity t =>
ParserState
-> Parsec s ParserState a -> String -> s -> Either ParseError a
runParserWith ParserState
state
  where
    state :: ParserState
state = forall a. Default a => a
def

debugRunParser :: (Stream s Identity t) => Parsec s ParserState a -> SourceName -> s -> Either ParseError a
debugRunParser :: forall s t a.
Stream s Identity t =>
Parsec s ParserState a -> String -> s -> Either ParseError a
debugRunParser = forall s t a.
Stream s Identity t =>
ParserState
-> Parsec s ParserState a -> String -> s -> Either ParseError a
runParserWith ParserState
state
  where
    state :: ParserState
state = forall a. Default a => a
def {parserStateIsDebugging :: Bool
parserStateIsDebugging = Bool
True}

runParserWith :: (Stream s Identity t) => ParserState -> Parsec s ParserState a -> SourceName -> s -> Either ParseError a
runParserWith :: forall s t a.
Stream s Identity t =>
ParserState
-> Parsec s ParserState a -> String -> s -> Either ParseError a
runParserWith ParserState
state Parsec s ParserState a
p = forall s t u a.
Stream s Identity t =>
Parsec s u a -> u -> String -> s -> Either ParseError a
P.runParser Parsec s ParserState a
p ParserState
state

labeled :: (Show t, Stream s m t) => String -> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled :: forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
String -> ParsecT s ParserState m a -> ParsecT s ParserState m a
labeled = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
ParsecT s ParserState m a -> String -> ParsecT s ParserState m a
(<?>)

(<?>) :: (Show t, Stream s m t) => ParsecT s ParserState m a -> String -> ParsecT s ParserState m a
ParsecT s ParserState m a
p <?> :: forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
ParsecT s ParserState m a -> String -> ParsecT s ParserState m a
<?> String
label = forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
String -> ParsecT s ParserState m a -> ParsecT s ParserState m a
traced String
label (ParsecT s ParserState m a
p forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
P.<?> String
label)

infix 0 <?>

whenDebugging :: (Stream s m t) => ParsecT s ParserState m () -> ParsecT s ParserState m ()
whenDebugging :: forall s (m :: * -> *) t.
Stream s m t =>
ParsecT s ParserState m () -> ParsecT s ParserState m ()
whenDebugging ParsecT s ParserState m ()
p = do
  Bool
isDebugging <- forall (m :: * -> *) s. Monad m => ParsecT s ParserState m Bool
getIsDebugging
  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
isDebugging ParsecT s ParserState m ()
p

trace :: (Show t, Stream s m t) => String -> ParsecT s ParserState m ()
trace :: forall t s (m :: * -> *).
(Show t, Stream s m t) =>
String -> ParsecT s ParserState m ()
trace String
label = forall s (m :: * -> *) t.
Stream s m t =>
ParsecT s ParserState m () -> ParsecT s ParserState m ()
whenDebugging forall a b. (a -> b) -> a -> b
$ forall t s (m :: * -> *) u.
(Show t, Stream s m t) =>
String -> ParsecT s u m ()
parserTrace String
label

traced :: (Show t, Stream s m t) => String -> ParsecT s ParserState m a -> ParsecT s ParserState m a
traced :: forall t s (m :: * -> *) a.
(Show t, Stream s m t) =>
String -> ParsecT s ParserState m a -> ParsecT s ParserState m a
traced String
label ParsecT s ParserState m a
p =
  forall (m :: * -> *) s. Monad m => ParsecT s ParserState m Bool
getIsDebugging forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Bool
True -> forall s (m :: * -> *) t u b.
(Stream s m t, Show t) =>
String -> ParsecT s u m b -> ParsecT s u m b
parserTraced String
label ParsecT s ParserState m a
p
    Bool
False -> ParsecT s ParserState m a
p

tryOne :: (Stream s m t) => [ParsecT s u m a] -> ParsecT s u m a
tryOne :: forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
tryOne = forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try

withPosition :: (Stream s m t) => ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition :: forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m (SourcePos -> a) -> ParsecT s u m a
withPosition ParsecT s u m (SourcePos -> a)
p = do
  SourcePos
pos <- forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  SourcePos -> a
f <- ParsecT s u m (SourcePos -> a)
p
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ SourcePos -> a
f SourcePos
pos

getIsDebugging :: (Monad m) => ParsecT s ParserState m Bool
getIsDebugging :: forall (m :: * -> *) s. Monad m => ParsecT s ParserState m Bool
getIsDebugging = ParserState -> Bool
parserStateIsDebugging forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState

getLexerMode :: (Monad m) => ParsecT s ParserState m LexerMode
getLexerMode :: forall (m :: * -> *) s.
Monad m =>
ParsecT s ParserState m LexerMode
getLexerMode = ParserState -> LexerMode
parserStateLexerMode forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState

putLexerMode :: (Monad m) => LexerMode -> ParsecT s ParserState m ()
putLexerMode :: forall (m :: * -> *) s.
Monad m =>
LexerMode -> ParsecT s ParserState m ()
putLexerMode LexerMode
mode = do
  ParserState
state <- forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
  forall (m :: * -> *) u s. Monad m => u -> ParsecT s u m ()
putState ParserState
state {parserStateLexerMode :: LexerMode
parserStateLexerMode = LexerMode
mode}