module Heist.Splices.Bind where

------------------------------------------------------------------------------
import           Data.Text (Text)
import qualified Data.Text as T
import qualified Text.XmlHtml as X

------------------------------------------------------------------------------
import           Heist.Common
import           Heist.Interpreted.Internal
import           Heist.Splices.Apply
import           Heist.Internal.Types.HeistState

-- | Default name for the bind splice.
bindTag :: Text
bindTag :: Text
bindTag = Text
"bind"


------------------------------------------------------------------------------
-- | Default attribute name for the bind tag.
bindAttr :: Text
bindAttr :: Text
bindAttr = Text
"tag"


------------------------------------------------------------------------------
-- | Implementation of the bind splice.
bindImpl :: Monad n => Splice n
bindImpl :: forall (n :: * -> *). Monad n => Splice n
bindImpl = do
    Node
node <- forall (m :: * -> *) (n :: * -> *). Monad m => HeistT n m Node
getParamNode
    let err :: [Char]
err = [Char]
"must supply \"" forall a. [a] -> [a] -> [a]
++ Text -> [Char]
T.unpack Text
bindAttr forall a. [a] -> [a] -> [a]
++
              [Char]
"\" attribute in <" forall a. [a] -> [a] -> [a]
++ Text -> [Char]
T.unpack (Node -> Text
X.elementTag Node
node) forall a. [a] -> [a] -> [a]
++ [Char]
">"
    forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a. Monad m => a -> m a
return () forall (m :: * -> *) (n :: * -> *) b.
Monad m =>
HeistT n m b -> [Char] -> HeistT n m b
`orError` [Char]
err)
          (forall {m :: * -> *} {n :: * -> *}.
(Monad m, Monad n) =>
Node -> Text -> HeistT n m ()
add Node
node)
          (Text -> Node -> Maybe Text
X.getAttribute Text
bindAttr Node
node)
    forall (m :: * -> *) a. Monad m => a -> m a
return []
  where
    add :: Node -> Text -> HeistT n m ()
add Node
node Text
nm = forall (m :: * -> *) (n :: * -> *).
Monad m =>
(HeistState n -> HeistState n) -> HeistT n m ()
modifyHS forall a b. (a -> b) -> a -> b
$ forall (n :: * -> *).
Text -> Splice n -> HeistState n -> HeistState n
bindSplice Text
nm forall a b. (a -> b) -> a -> b
$ do
        Node
caller <- forall (m :: * -> *) (n :: * -> *). Monad m => HeistT n m Node
getParamNode
        TPath
ctx <- forall (m :: * -> *) (n :: * -> *). Monad m => HeistT n m TPath
getContext
        forall (n :: * -> *).
Monad n =>
Text -> [Node] -> Maybe [Char] -> TPath -> [Node] -> Splice n
rawApply Text
"bind-content" (Node -> [Node]
X.childNodes Node
node)
                 forall a. Maybe a
Nothing TPath
ctx (Node -> [Node]
X.childNodes Node
caller)