{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PackageImports #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Heist.Interpreted.Internal where
import Blaze.ByteString.Builder
import Control.Monad
import Control.Monad.State.Strict
import qualified Data.Attoparsec.Text as AP
import Data.ByteString (ByteString)
import qualified Data.HashMap.Strict as Map
import qualified Data.HeterogeneousEnvironment as HE
import Data.Map.Syntax
import Data.Maybe
import Data.Text (Text)
import qualified Data.Text as T
import qualified Text.XmlHtml as X
import Heist.Common
import Heist.Internal.Types.HeistState
type Splice n = HeistT n n Template
bindSplice :: Text
-> Splice n
-> HeistState n
-> HeistState n
bindSplice :: forall (n :: * -> *).
Text -> Splice n -> HeistState n -> HeistState n
bindSplice Text
n Splice n
v HeistState n
hs = HeistState n
hs {_spliceMap :: HashMap Text (Splice n)
_spliceMap = forall k v.
(Eq k, Hashable k) =>
k -> v -> HashMap k v -> HashMap k v
Map.insert Text
n Splice n
v (forall (m :: * -> *).
HeistState m -> HashMap Text (HeistT m m Template)
_spliceMap HeistState n
hs)}
bindSplices :: Splices (Splice n)
-> HeistState n
-> HeistState n
bindSplices :: forall (n :: * -> *).
Splices (Splice n) -> HeistState n -> HeistState n
bindSplices Splices (Splice n)
ss HeistState n
hs =
HeistState n
hs { _spliceMap :: HashMap Text (Splice n)
_spliceMap = forall (n :: * -> *) v a.
HeistState n
-> (HeistState n -> HashMap Text v)
-> MapSyntaxM Text v a
-> HashMap Text v
applySpliceMap HeistState n
hs forall (m :: * -> *).
HeistState m -> HashMap Text (HeistT m m Template)
_spliceMap Splices (Splice n)
ss }
textSplice :: Monad m => Text -> HeistT n m Template
textSplice :: forall (m :: * -> *) (n :: * -> *).
Monad m =>
Text -> HeistT n m Template
textSplice Text
t = forall (m :: * -> *) a. Monad m => a -> m a
return [Text -> Node
X.TextNode Text
t]
runChildren :: Monad n => Splice n
runChildren :: forall (n :: * -> *). Monad n => Splice n
runChildren = forall (n :: * -> *). Monad n => Template -> Splice n
runNodeList forall b c a. (b -> c) -> (a -> b) -> a -> c
. Node -> Template
X.childNodes forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (m :: * -> *) (n :: * -> *). Monad m => HeistT n m Node
getParamNode
runChildrenWith :: (Monad n)
=> Splices (Splice n)
-> Splice n
runChildrenWith :: forall (n :: * -> *). Monad n => Splices (Splice n) -> Splice n
runChildrenWith Splices (Splice n)
splices = forall (m :: * -> *) (n :: * -> *) a.
Monad m =>
(HeistState n -> HeistState n) -> HeistT n m a -> HeistT n m a
localHS (forall (n :: * -> *).
Splices (Splice n) -> HeistState n -> HeistState n
bindSplices Splices (Splice n)
splices) forall (n :: * -> *). Monad n => Splice n
runChildren
runChildrenWithTrans :: (Monad n)
=> (b -> Splice n)
-> Splices b
-> Splice n
runChildrenWithTrans :: forall (n :: * -> *) b.
Monad n =>
(b -> Splice n) -> Splices b -> Splice n
runChildrenWithTrans b -> Splice n
f = forall (n :: * -> *). Monad n => Splices (Splice n) -> Splice n
runChildrenWith forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v1 v2 k a. (v1 -> v2) -> MapSyntaxM k v1 a -> MapSyntax k v2
mapV b -> Splice n
f
runChildrenWithTemplates :: (Monad n) => Splices Template -> Splice n
runChildrenWithTemplates :: forall (n :: * -> *). Monad n => Splices Template -> Splice n
runChildrenWithTemplates = forall (n :: * -> *) b.
Monad n =>
(b -> Splice n) -> Splices b -> Splice n
runChildrenWithTrans forall (m :: * -> *) a. Monad m => a -> m a
return
runChildrenWithText :: (Monad n) => Splices Text -> Splice n
runChildrenWithText :: forall (n :: * -> *). Monad n => Splices Text -> Splice n
runChildrenWithText = forall (n :: * -> *) b.
Monad n =>
(b -> Splice n) -> Splices b -> Splice n
runChildrenWithTrans forall (m :: * -> *) (n :: * -> *).
Monad m =>
Text -> HeistT n m Template
textSplice
lookupSplice :: Text
-> HeistState n
-> Maybe (Splice n)
lookupSplice :: forall (n :: * -> *). Text -> HeistState n -> Maybe (Splice n)
lookupSplice Text
nm HeistState n
hs = forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
Map.lookup Text
nm forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *).
HeistState m -> HashMap Text (HeistT m m Template)
_spliceMap HeistState n
hs
{-# INLINE lookupSplice #-}
addTemplate :: ByteString
-> Template
-> Maybe FilePath
-> HeistState n
-> HeistState n
addTemplate :: forall (n :: * -> *).
ByteString
-> Template -> Maybe FilePath -> HeistState n -> HeistState n
addTemplate ByteString
n Template
t Maybe FilePath
mfp HeistState n
st =
forall (n :: * -> *).
TPath -> DocumentFile -> HeistState n -> HeistState n
insertTemplate (ByteString -> TPath
splitTemplatePath ByteString
n) DocumentFile
doc HeistState n
st
where
doc :: DocumentFile
doc = Document -> Maybe FilePath -> DocumentFile
DocumentFile (Encoding -> Maybe DocType -> Template -> Document
X.HtmlDocument Encoding
X.UTF8 forall a. Maybe a
Nothing Template
t) Maybe FilePath
mfp
addXMLTemplate :: ByteString
-> Template
-> Maybe FilePath
-> HeistState n
-> HeistState n
addXMLTemplate :: forall (n :: * -> *).
ByteString
-> Template -> Maybe FilePath -> HeistState n -> HeistState n
addXMLTemplate ByteString
n Template
t Maybe FilePath
mfp HeistState n
st =
forall (n :: * -> *).
TPath -> DocumentFile -> HeistState n -> HeistState n
insertTemplate (ByteString -> TPath
splitTemplatePath ByteString
n) DocumentFile
doc HeistState n
st
where
doc :: DocumentFile
doc = Document -> Maybe FilePath -> DocumentFile
DocumentFile (Encoding -> Maybe DocType -> Template -> Document
X.XmlDocument Encoding
X.UTF8 forall a. Maybe a
Nothing Template
t) Maybe FilePath
mfp
stopRecursion :: Monad m => HeistT n m ()
stopRecursion :: forall (m :: * -> *) (n :: * -> *). Monad m => HeistT n m ()
stopRecursion = forall (m :: * -> *) (n :: * -> *).
Monad m =>
(HeistState n -> HeistState n) -> HeistT n m ()
modifyHS (\HeistState n
st -> HeistState n
st { _recurse :: Bool
_recurse = Bool
False })
runNode :: Monad n => X.Node -> Splice n
runNode :: forall (n :: * -> *). Monad n => Node -> Splice n
runNode (X.Element Text
nm [(Text, Text)]
at Template
ch) = do
[(Text, Text)]
newAtts <- forall (n :: * -> *).
Monad n =>
[(Text, Text)] -> HeistT n n [(Text, Text)]
runAttributes [(Text, Text)]
at
let n :: Node
n = Text -> [(Text, Text)] -> Template -> Node
X.Element Text
nm [(Text, Text)]
newAtts Template
ch
Maybe (Splice n)
s <- forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall (n :: * -> *). Text -> HeistState n -> Maybe (Splice n)
lookupSplice Text
nm) forall (m :: * -> *) (n :: * -> *).
Monad m =>
HeistT n m (HeistState n)
getHS
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall {n :: * -> *}.
Monad n =>
[(Text, Text)] -> HeistT n n Template
runKids [(Text, Text)]
newAtts) (forall (n :: * -> *). Monad n => Node -> Splice n -> Splice n
recurseSplice Node
n) Maybe (Splice n)
s
where
runKids :: [(Text, Text)] -> HeistT n n Template
runKids [(Text, Text)]
newAtts = do
Template
newKids <- forall (n :: * -> *). Monad n => Template -> Splice n
runNodeList Template
ch
forall (m :: * -> *) a. Monad m => a -> m a
return [Text -> [(Text, Text)] -> Template -> Node
X.Element Text
nm [(Text, Text)]
newAtts Template
newKids]
runNode Node
n = forall (m :: * -> *) a. Monad m => a -> m a
return [Node
n]
runAttributes :: Monad n => [(Text, Text)] -> HeistT n n [(Text, Text)]
runAttributes :: forall (n :: * -> *).
Monad n =>
[(Text, Text)] -> HeistT n n [(Text, Text)]
runAttributes [(Text, Text)]
attrs = (forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat) forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall (n :: * -> *).
Monad n =>
(Text, Text) -> HeistT n n [(Text, Text)]
runAttrSplice [(Text, Text)]
attrs
runAttrSplice :: (Monad n) => (Text, Text) -> HeistT n n [(Text, Text)]
runAttrSplice :: forall (n :: * -> *).
Monad n =>
(Text, Text) -> HeistT n n [(Text, Text)]
runAttrSplice a :: (Text, Text)
a@(Text
k,Text
v) = do
Maybe (AttrSplice n)
splice <- forall (m :: * -> *) (n :: * -> *) r.
Monad m =>
(HeistState n -> r) -> HeistT n m r
getsHS (forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
Map.lookup Text
k forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). HeistState m -> HashMap Text (AttrSplice m)
_attrSpliceMap)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall a. a -> [a] -> [a]
:[]) forall a b. (a -> b) -> a -> b
$ forall (n :: * -> *) t.
Monad n =>
(t, Text) -> HeistT n n (t, Text)
attSubst (Text, Text)
a)
(forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> b -> a -> c
flip forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT HeterogeneousEnvironment
HE.empty forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
RuntimeSplice m a -> StateT HeterogeneousEnvironment m a
unRT forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a b. (a -> b) -> a -> b
$ Text
v)) Maybe (AttrSplice n)
splice
attSubst :: (Monad n) => (t, Text) -> HeistT n n (t, Text)
attSubst :: forall (n :: * -> *) t.
Monad n =>
(t, Text) -> HeistT n n (t, Text)
attSubst (t
n,Text
v) = do
Text
v' <- forall (n :: * -> *). Monad n => Text -> HeistT n n Text
parseAtt Text
v
forall (m :: * -> *) a. Monad m => a -> m a
return (t
n,Text
v')
parseAtt :: (Monad n) => Text -> HeistT n n Text
parseAtt :: forall (n :: * -> *). Monad n => Text -> HeistT n n Text
parseAtt Text
bs = do
let ast :: [AttAST]
ast = case forall i r. Monoid i => IResult i r -> i -> IResult i r
AP.feed (forall a. Parser a -> Text -> Result a
AP.parse Parser [AttAST]
attParser Text
bs) Text
"" of
(AP.Done Text
_ [AttAST]
res) -> [AttAST]
res
(AP.Fail Text
_ [FilePath]
_ FilePath
_) -> []
(AP.Partial Text -> IResult Text [AttAST]
_) -> []
[Text]
chunks <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall {m :: * -> *}. Monad m => AttAST -> HeistT m m Text
cvt [AttAST]
ast
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Text] -> Text
T.concat [Text]
chunks
where
cvt :: AttAST -> HeistT m m Text
cvt (Literal Text
x) = forall (m :: * -> *) a. Monad m => a -> m a
return Text
x
cvt (Ident Text
x) =
forall (m :: * -> *) (n :: * -> *) a.
Monad m =>
(Node -> Node) -> HeistT n m a -> HeistT n m a
localParamNode (forall a b. a -> b -> a
const forall a b. (a -> b) -> a -> b
$ Text -> [(Text, Text)] -> Template -> Node
X.Element Text
x [] []) forall a b. (a -> b) -> a -> b
$ forall (n :: * -> *). Monad n => Text -> HeistT n n Text
getAttributeSplice Text
x
getAttributeSplice :: Monad n => Text -> HeistT n n Text
getAttributeSplice :: forall (n :: * -> *). Monad n => Text -> HeistT n n Text
getAttributeSplice Text
name = do
HeistState n
hs <- forall (m :: * -> *) (n :: * -> *).
Monad m =>
HeistT n m (HeistState n)
getHS
let noSplice :: m Text
noSplice = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ [Text] -> Text
T.concat [Text
"${", Text
name, Text
"}"]
s :: Maybe (Splice n)
s = forall (n :: * -> *). Text -> HeistState n -> Maybe (Splice n)
lookupSplice Text
name HeistState n
hs
forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall {m :: * -> *}. Monad m => m Text
noSplice (forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM ([Text] -> Text
T.concat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map Node -> Text
X.nodeText)) Maybe (Splice n)
s
runNodeList :: Monad n => [X.Node] -> Splice n
runNodeList :: forall (n :: * -> *). Monad n => Template -> Splice n
runNodeList = forall (m :: * -> *) b a.
(Monad m, Monoid b) =>
(a -> m b) -> [a] -> m b
mapSplices forall (n :: * -> *). Monad n => Node -> Splice n
runNode
{-# INLINE runNodeList #-}
mAX_RECURSION_DEPTH :: Int
mAX_RECURSION_DEPTH :: Int
mAX_RECURSION_DEPTH = Int
50
recurseSplice :: Monad n => X.Node -> Splice n -> Splice n
recurseSplice :: forall (n :: * -> *). Monad n => Node -> Splice n -> Splice n
recurseSplice Node
node Splice n
splice = do
Template
result <- forall (m :: * -> *) (n :: * -> *) a.
Monad m =>
(Node -> Node) -> HeistT n m a -> HeistT n m a
localParamNode (forall a b. a -> b -> a
const Node
node) Splice n
splice
HeistState n
hs <- forall (m :: * -> *) (n :: * -> *).
Monad m =>
HeistT n m (HeistState n)
getHS
if forall (m :: * -> *). HeistState m -> Bool
_recurse HeistState n
hs
then if forall (m :: * -> *). HeistState m -> Int
_recursionDepth HeistState n
hs forall a. Ord a => a -> a -> Bool
< Int
mAX_RECURSION_DEPTH
then do forall (m :: * -> *) (n :: * -> *).
Monad m =>
(Int -> Int) -> HeistT n m ()
modRecursionDepth (forall a. Num a => a -> a -> a
+Int
1)
Template
res <- forall (n :: * -> *). Monad n => Template -> Splice n
runNodeList Template
result
forall (m :: * -> *) (n :: * -> *).
Monad m =>
HeistState n -> HeistT n m ()
restoreHS HeistState n
hs
forall (m :: * -> *) a. Monad m => a -> m a
return Template
res
else forall (m :: * -> *) a. Monad m => a -> m a
return Template
result forall (m :: * -> *) (n :: * -> *) b.
Monad m =>
HeistT n m b -> FilePath -> HeistT n m b
`orError` FilePath
err
else do forall (m :: * -> *) (n :: * -> *).
Monad m =>
(HeistState n -> HeistState n) -> HeistT n m ()
modifyHS (\HeistState n
st -> HeistState n
st { _recurse :: Bool
_recurse = Bool
True })
forall (m :: * -> *) a. Monad m => a -> m a
return Template
result
where
err :: FilePath
err = [FilePath] -> FilePath
unwords
[FilePath
"Recursion limit reached in node"
,FilePath
"<"forall a. [a] -> [a] -> [a]
++(Text -> FilePath
T.unpack forall a b. (a -> b) -> a -> b
$ Node -> Text
X.elementTag Node
node)forall a. [a] -> [a] -> [a]
++FilePath
">. You"
,FilePath
"probably have infinite splice recursion!"
]
lookupAndRun :: Monad m
=> ByteString
-> ((DocumentFile, TPath) -> HeistT n m (Maybe a))
-> HeistT n m (Maybe a)
lookupAndRun :: forall (m :: * -> *) (n :: * -> *) a.
Monad m =>
ByteString
-> ((DocumentFile, TPath) -> HeistT n m (Maybe a))
-> HeistT n m (Maybe a)
lookupAndRun ByteString
name (DocumentFile, TPath) -> HeistT n m (Maybe a)
k = do
HeistState n
hs <- forall (m :: * -> *) (n :: * -> *).
Monad m =>
HeistT n m (HeistState n)
getHS
let mt :: Maybe (DocumentFile, TPath)
mt = forall (n :: * -> *) t.
ByteString
-> HeistState n
-> (HeistState n -> HashMap TPath t)
-> Maybe (t, TPath)
lookupTemplate ByteString
name HeistState n
hs forall (m :: * -> *). HeistState m -> HashMap TPath DocumentFile
_templateMap
let curPath :: Maybe FilePath
curPath = forall (m :: * -> *) a. Monad m => m (m a) -> m a
join forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (DocumentFile -> Maybe FilePath
dfFile forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> a
fst) Maybe (DocumentFile, TPath)
mt
forall (m :: * -> *) (n :: * -> *).
Monad m =>
(HeistState n -> HeistState n) -> HeistT n m ()
modifyHS (forall (n :: * -> *).
Maybe FilePath -> HeistState n -> HeistState n
setCurTemplateFile Maybe FilePath
curPath)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing) (DocumentFile, TPath) -> HeistT n m (Maybe a)
k Maybe (DocumentFile, TPath)
mt
evalTemplate :: Monad n
=> ByteString
-> HeistT n n (Maybe Template)
evalTemplate :: forall (n :: * -> *).
Monad n =>
ByteString -> HeistT n n (Maybe Template)
evalTemplate ByteString
name = forall (m :: * -> *) (n :: * -> *) a.
Monad m =>
ByteString
-> ((DocumentFile, TPath) -> HeistT n m (Maybe a))
-> HeistT n m (Maybe a)
lookupAndRun ByteString
name
(\(DocumentFile
t,TPath
ctx) -> forall (m :: * -> *) (n :: * -> *) a.
Monad m =>
(HeistState n -> HeistState n) -> HeistT n m a -> HeistT n m a
localHS (\HeistState n
hs -> HeistState n
hs {_curContext :: TPath
_curContext = TPath
ctx})
(forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall (n :: * -> *). Monad n => Template -> Splice n
runNodeList forall a b. (a -> b) -> a -> b
$ Document -> Template
X.docContent forall a b. (a -> b) -> a -> b
$ DocumentFile -> Document
dfDoc DocumentFile
t))
fixDocType :: Monad m => X.Document -> HeistT n m X.Document
fixDocType :: forall (m :: * -> *) (n :: * -> *).
Monad m =>
Document -> HeistT n m Document
fixDocType Document
d = do
[DocType]
dts <- forall (m :: * -> *) (n :: * -> *) r.
Monad m =>
(HeistState n -> r) -> HeistT n m r
getsHS forall (m :: * -> *). HeistState m -> [DocType]
_doctypes
forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Document
d { docType :: Maybe DocType
X.docType = forall a. [a] -> Maybe a
listToMaybe [DocType]
dts }
evalWithDoctypes :: Monad n
=> ByteString
-> HeistT n n (Maybe X.Document)
evalWithDoctypes :: forall (n :: * -> *).
Monad n =>
ByteString -> HeistT n n (Maybe Document)
evalWithDoctypes ByteString
name = forall (m :: * -> *) (n :: * -> *) a.
Monad m =>
ByteString
-> ((DocumentFile, TPath) -> HeistT n m (Maybe a))
-> HeistT n m (Maybe a)
lookupAndRun ByteString
name forall a b. (a -> b) -> a -> b
$ \(DocumentFile
t,TPath
ctx) -> do
forall (m :: * -> *) (n :: * -> *).
Monad m =>
[DocType] -> HeistT n m ()
addDoctype forall a b. (a -> b) -> a -> b
$ forall a. Maybe a -> [a]
maybeToList forall a b. (a -> b) -> a -> b
$ Document -> Maybe DocType
X.docType forall a b. (a -> b) -> a -> b
$ DocumentFile -> Document
dfDoc DocumentFile
t
HeistState n
hs <- forall (m :: * -> *) (n :: * -> *).
Monad m =>
HeistT n m (HeistState n)
getHS
let nodes :: Template
nodes = Document -> Template
X.docContent forall a b. (a -> b) -> a -> b
$ DocumentFile -> Document
dfDoc DocumentFile
t
forall (m :: * -> *) (n :: * -> *).
Monad m =>
HeistState n -> HeistT n m ()
putHS (HeistState n
hs {_curContext :: TPath
_curContext = TPath
ctx})
Template
newNodes <- forall (n :: * -> *). Monad n => Template -> Splice n
runNodeList Template
nodes
forall (m :: * -> *) (n :: * -> *).
Monad m =>
HeistState n -> HeistT n m ()
restoreHS HeistState n
hs
Document
newDoc <- forall (m :: * -> *) (n :: * -> *).
Monad m =>
Document -> HeistT n m Document
fixDocType forall a b. (a -> b) -> a -> b
$ (DocumentFile -> Document
dfDoc DocumentFile
t) { docContent :: Template
X.docContent = Template
newNodes }
forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just Document
newDoc)
bindStrings :: Monad n
=> Splices Text
-> HeistState n
-> HeistState n
bindStrings :: forall (n :: * -> *).
Monad n =>
Splices Text -> HeistState n -> HeistState n
bindStrings Splices Text
splices = forall (n :: * -> *).
Splices (Splice n) -> HeistState n -> HeistState n
bindSplices (forall v1 v2 k a. (v1 -> v2) -> MapSyntaxM k v1 a -> MapSyntax k v2
mapV forall (m :: * -> *) (n :: * -> *).
Monad m =>
Text -> HeistT n m Template
textSplice Splices Text
splices)
bindString :: Monad n
=> Text
-> Text
-> HeistState n
-> HeistState n
bindString :: forall (n :: * -> *).
Monad n =>
Text -> Text -> HeistState n -> HeistState n
bindString Text
n = forall (n :: * -> *).
Text -> Splice n -> HeistState n -> HeistState n
bindSplice Text
n forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) (n :: * -> *).
Monad m =>
Text -> HeistT n m Template
textSplice
callTemplate :: Monad n
=> ByteString
-> Splices (Splice n)
-> HeistT n n Template
callTemplate :: forall (n :: * -> *).
Monad n =>
ByteString -> Splices (Splice n) -> Splice n
callTemplate ByteString
name Splices (Splice n)
splices = do
forall (m :: * -> *) (n :: * -> *).
Monad m =>
(HeistState n -> HeistState n) -> HeistT n m ()
modifyHS forall a b. (a -> b) -> a -> b
$ forall (n :: * -> *).
Splices (Splice n) -> HeistState n -> HeistState n
bindSplices Splices (Splice n)
splices
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] forall a. a -> a
id) forall a b. (a -> b) -> a -> b
$ forall (n :: * -> *).
Monad n =>
ByteString -> HeistT n n (Maybe Template)
evalTemplate ByteString
name
callTemplateWithText :: Monad n
=> ByteString
-> Splices Text
-> HeistT n n Template
callTemplateWithText :: forall (n :: * -> *).
Monad n =>
ByteString -> Splices Text -> HeistT n n Template
callTemplateWithText ByteString
name Splices Text
splices = forall (n :: * -> *).
Monad n =>
ByteString -> Splices (Splice n) -> Splice n
callTemplate ByteString
name forall a b. (a -> b) -> a -> b
$ forall v1 v2 k a. (v1 -> v2) -> MapSyntaxM k v1 a -> MapSyntax k v2
mapV forall (m :: * -> *) (n :: * -> *).
Monad m =>
Text -> HeistT n m Template
textSplice Splices Text
splices
renderTemplate :: Monad n
=> HeistState n
-> ByteString
-> n (Maybe (Builder, MIMEType))
renderTemplate :: forall (n :: * -> *).
Monad n =>
HeistState n -> ByteString -> n (Maybe (Builder, ByteString))
renderTemplate HeistState n
hs ByteString
name = forall (m :: * -> *) (n :: * -> *) a.
Monad m =>
HeistT n m a -> Node -> HeistState n -> m a
evalHeistT forall {n :: * -> *}.
Monad n =>
HeistT n n (Maybe (Builder, ByteString))
tpl (Text -> Node
X.TextNode Text
"") HeistState n
hs
where tpl :: HeistT n n (Maybe (Builder, ByteString))
tpl = do Maybe Document
mt <- forall (n :: * -> *).
Monad n =>
ByteString -> HeistT n n (Maybe Document)
evalWithDoctypes ByteString
name
case Maybe Document
mt of
Maybe Document
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
Just Document
doc -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ (Document -> Builder
X.render Document
doc, Document -> ByteString
mimeType Document
doc)
renderWithArgs :: Monad n
=> Splices Text
-> HeistState n
-> ByteString
-> n (Maybe (Builder, MIMEType))
renderWithArgs :: forall (n :: * -> *).
Monad n =>
Splices Text
-> HeistState n -> ByteString -> n (Maybe (Builder, ByteString))
renderWithArgs Splices Text
args HeistState n
hs = forall (n :: * -> *).
Monad n =>
HeistState n -> ByteString -> n (Maybe (Builder, ByteString))
renderTemplate (forall (n :: * -> *).
Monad n =>
Splices Text -> HeistState n -> HeistState n
bindStrings Splices Text
args HeistState n
hs)
renderTemplateToDoc :: Monad n
=> HeistState n
-> ByteString
-> n (Maybe X.Document)
renderTemplateToDoc :: forall (n :: * -> *).
Monad n =>
HeistState n -> ByteString -> n (Maybe Document)
renderTemplateToDoc HeistState n
hs ByteString
name =
forall (m :: * -> *) (n :: * -> *) a.
Monad m =>
HeistT n m a -> Node -> HeistState n -> m a
evalHeistT (forall (n :: * -> *).
Monad n =>
ByteString -> HeistT n n (Maybe Document)
evalWithDoctypes ByteString
name) (Text -> Node
X.TextNode Text
"") HeistState n
hs