heist 0.2.1 → 0.2.2

raw patch · 6 files changed

+140/−27 lines, 6 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• heist.cabal +3/−2
• src/Text/Templating/Heist.hs +9/−0
• src/Text/Templating/Heist/Internal.hs +24/−19
• src/Text/Templating/Heist/Splices/Apply.hs +1/−1
• src/Text/Templating/Heist/TemplateDirectory.hs +85/−0
• src/Text/Templating/Heist/Types.hs +18/−5

@@ -1,5 +1,5 @@ name:           heist-version:        0.2.1+version:        0.2.2 synopsis:       An xhtml templating system license:        BSD3 license-file:   LICENSE@@ -79,7 +79,8 @@     Text.Templating.Heist.Splices.Bind,     Text.Templating.Heist.Splices.Ignore,     Text.Templating.Heist.Splices.Markdown,-    Text.Templating.Heist.Splices.Static+    Text.Templating.Heist.Splices.Static,+    Text.Templating.Heist.TemplateDirectory    other-modules:     Text.Templating.Heist.Internal,

@@ -73,9 +73,11 @@   , addTemplate   , emptyTemplateState   , bindSplice+  , bindSplices   , lookupSplice   , setTemplates   , loadTemplates+  , hasTemplate      -- * Hook functions     -- $hookDoc@@ -88,6 +90,13 @@   , getParamNode   , runNodeList   , getContext++  , localParamNode+  , getsTS+  , getTS+  , putTS+  , modifyTS+  , restoreTS      -- * Functions for running splices and templates   , evalTemplate

@@ -31,21 +31,6 @@   --------------------------------------------------------------------------------- | Restores the components of TemplateState that can get modified in--- template calls.  You should use this function instead of @putTS@ to restore--- an old state.  Thas was needed because doctypes needs to be in a "global--- scope" as opposed to the template call "local scope" of state items such--- as recursionDepth, curContext, and spliceMap.-restoreState :: Monad m => TemplateState m -> TemplateMonad m ()-restoreState ts1 = -    modifyTS (\ts2 -> ts2-        { _recursionDepth = _recursionDepth ts1-        , _curContext = _curContext ts1-        , _spliceMap = _spliceMap ts1-        })--------------------------------------------------------------------------------- -- | Mappends a doctype to the state. addDoctype :: Monad m => [ByteString] -> TemplateMonad m () addDoctype dt = do@@ -85,7 +70,7 @@   --------------------------------------------------------------------------------- | Bind a new splice declaration to a tag name within a 'TemplateState'.+-- | Binds a new splice declaration to a tag name within a 'TemplateState'. bindSplice :: Monad m =>               ByteString        -- ^ tag name            -> Splice m          -- ^ splice action@@ -95,6 +80,17 @@   ------------------------------------------------------------------------------+-- | Binds a set of new splice declarations within a 'TemplateState'.+bindSplices :: Monad m =>+               [(ByteString, Splice m)] -- ^ splices to bind+            -> TemplateState m   -- ^ start state+            -> TemplateState m+bindSplices ss ts = foldl' (flip id) ts acts +  where+    acts = map (uncurry bindSplice) ss+++------------------------------------------------------------------------------ -- | Convenience function for looking up a splice. lookupSplice :: Monad m =>                 ByteString@@ -150,6 +146,15 @@   ------------------------------------------------------------------------------+-- | Returns 'True' if the given template can be found in the template state.+hasTemplate :: Monad m =>+               ByteString+            -> TemplateState m+            -> Bool+hasTemplate nameStr ts = isJust $ lookupTemplate nameStr ts+++------------------------------------------------------------------------------ -- | Convenience function for looking up a template. lookupTemplate :: Monad m =>                   ByteString@@ -333,7 +338,7 @@     if _recurse ts' && _recursionDepth ts' < mAX_RECURSION_DEPTH         then do modRecursionDepth (+1)                 res <- runNodeList result-                restoreState ts'+                restoreTS ts'                 return res         else return result   where@@ -364,7 +369,7 @@         ts <- getTS         putTS (ts {_curContext = ctx})         res <- runNodeList $ _itNodes t-        restoreState ts+        restoreTS ts         return $ Just res)  @@ -381,7 +386,7 @@         nodes <- lift $ _preRunHook ts $ _itNodes t         putTS (ts {_curContext = ctx})         res <- runNodeList nodes-        restoreState ts+        restoreTS ts         return . Just =<< lift (_postRunHook ts res))  

@@ -41,7 +41,7 @@                       modifyTS (bindSplice "content" $ return processedChildren)                       setContext ctx                       result <- runNodeList $ _itNodes t-                      restoreState st+                      restoreTS st                       return result)                   (lookupTemplate attr (st {_curContext = nextCtx attr st}))   where nextCtx name st

@@ -0,0 +1,85 @@+{-|++This module defines a TemplateDirectory data structure for convenient+interaction with templates within web apps.++-}++module Text.Templating.Heist.TemplateDirectory+    ( TemplateDirectory+    , newTemplateDirectory+    , newTemplateDirectory'++    , getDirectoryTS+    , reloadTemplateDirectory+    ) where++------------------------------------------------------------------------------+import           Control.Concurrent+import           Control.Monad+import           Control.Monad.Trans+import           Data.ByteString.Char8 (ByteString)+import           Text.Templating.Heist+import           Text.Templating.Heist.Splices.Static+++------------------------------------------------------------------------------+-- | Structure representing a template directory.+data TemplateDirectory m+    = TemplateDirectory+        FilePath+        (TemplateState m)+        (MVar (TemplateState m))+        StaticTagState+++------------------------------------------------------------------------------+-- | Creates and returns a new 'TemplateDirectory' wrapped in an Either for+-- error handling.+newTemplateDirectory :: (MonadIO m, MonadIO n)+                     => FilePath+                     -> TemplateState m+                     -> n (Either String (TemplateDirectory m))+newTemplateDirectory dir templateState = liftIO $ do+    (origTs,sts) <- bindStaticTag templateState+    ets <- loadTemplates dir origTs+    leftPass ets $ \ts -> do+        tsMVar <- newMVar $ ts+        return $ TemplateDirectory dir origTs tsMVar sts+++------------------------------------------------------------------------------+-- | Creates and returns a new 'TemplateDirectory', using the monad's fail+-- function on error.+newTemplateDirectory' :: (MonadIO m, MonadIO n)+                      => FilePath+                      -> TemplateState m+                      -> n (TemplateDirectory m)+newTemplateDirectory' = ((either fail return =<<) .) . newTemplateDirectory+++------------------------------------------------------------------------------+-- | Gets the 'TemplateState' from a TemplateDirectory.+getDirectoryTS :: (Monad m, MonadIO n)+               => TemplateDirectory m+               -> n (TemplateState m)+getDirectoryTS (TemplateDirectory _ _ tsMVar _) = liftIO $ readMVar $ tsMVar+++------------------------------------------------------------------------------+-- | Clears cached content and reloads templates from disk.+reloadTemplateDirectory :: (MonadIO m, MonadIO n)+                        => TemplateDirectory m+                        -> n (Either String ())+reloadTemplateDirectory (TemplateDirectory p origTs tsMVar sts) = liftIO $ do+    clearStaticTagCache sts+    ets <- loadTemplates p origTs+    leftPass ets $ \ts -> modifyMVar_ tsMVar (const $ return ts)+++------------------------------------------------------------------------------+-- | Prepends an error onto a Left.+leftPass :: Monad m => Either String b -> (b -> m c) -> m (Either String c)+leftPass e m = either (return . Left . loadError) (liftM Right . m) e+  where+    loadError = (++) "Error loading templates: "

@@ -320,7 +320,7 @@   --------------------------------------------------------------------------------- | TemplateMonad's local+-- | TemplateMonad's 'local'. localParamNode :: Monad m                => (Node -> Node)                -> TemplateMonad m a@@ -329,28 +329,41 @@   --------------------------------------------------------------------------------- | TemplateMonad's gets+-- | TemplateMonad's 'gets'. getsTS :: Monad m => (TemplateState m -> r) -> TemplateMonad m r getsTS f = TemplateMonad $ \_ s -> return (f s, s)   --------------------------------------------------------------------------------- | TemplateMonad's get+-- | TemplateMonad's 'get'. getTS :: Monad m => TemplateMonad m (TemplateState m) getTS = TemplateMonad $ \_ s -> return (s, s)   --------------------------------------------------------------------------------- | TemplateMonad's put+-- | TemplateMonad's 'put'. putTS :: Monad m => TemplateState m -> TemplateMonad m () putTS s = TemplateMonad $ \_ _ -> return ((), s)   --------------------------------------------------------------------------------- | TemplateMonad's modify+-- | TemplateMonad's 'modify'. modifyTS :: Monad m                     => (TemplateState m -> TemplateState m)                     -> TemplateMonad m () modifyTS f = TemplateMonad $ \_ s -> return ((), f s)  +------------------------------------------------------------------------------+-- | Restores the components of TemplateState that can get modified in+-- template calls.  You should use this function instead of @putTS@ to restore+-- an old state.  Thas was needed because doctypes needs to be in a "global+-- scope" as opposed to the template call "local scope" of state items such+-- as recursionDepth, curContext, and spliceMap.+restoreTS :: Monad m => TemplateState m -> TemplateMonad m ()+restoreTS ts1 = +    modifyTS (\ts2 -> ts2+        { _recursionDepth = _recursionDepth ts1+        , _curContext = _curContext ts1+        , _spliceMap = _spliceMap ts1+        })