summaryrefslogtreecommitdiff
path: root/src/Text/Hakyll/RenderAction.hs
blob: 62ac713c21b95c62d9eb2d5867f99537e76fa3ed (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
module Text.Hakyll.RenderAction
    ( RenderAction (..)
    , createRenderAction
    , createSimpleRenderAction
    , createFileRenderAction
    , createManipulationAction
    , chain
    , runRenderAction
    , runRenderActionIfNeeded
    , Renderable
    ) where

import Control.Category
import Control.Monad ((<=<), mplus, unless)
import Control.Monad.Reader (liftIO)
import Prelude hiding ((.), id)
import System.IO (hPutStrLn, stderr)

import Text.Hakyll.Context
import Text.Hakyll.File (toDestination, isFileMoreRecent)
import Text.Hakyll.Hakyll

data RenderAction a b = RenderAction
    { actionDependencies :: [FilePath]
    , actionUrl          :: Maybe (Hakyll FilePath)
    , actionFunction     :: a -> Hakyll b
    }

createRenderAction :: (a -> Hakyll b) -> RenderAction a b
createRenderAction f = id { actionFunction = f }

createSimpleRenderAction :: Hakyll b -> RenderAction () b
createSimpleRenderAction = createRenderAction . const

createFileRenderAction :: FilePath -> Hakyll b -> RenderAction () b
createFileRenderAction path action = RenderAction
    { actionDependencies = [path]
    , actionUrl          = Just $ return path
    , actionFunction     = const action
    }

instance Category RenderAction where
    id = RenderAction
        { actionDependencies = []
        , actionUrl          = Nothing
        , actionFunction     = return
        }

    x . y = RenderAction
        { actionDependencies = actionDependencies x ++ actionDependencies y
        , actionUrl          = actionUrl y `mplus` actionUrl x
        , actionFunction     = actionFunction x <=< actionFunction y
        }

createManipulationAction :: ContextManipulation -> RenderAction Context Context
createManipulationAction = createRenderAction . (return .)

chain :: [RenderAction a a] -> RenderAction a a
chain []         = id
chain list@(_:_) = foldl1 (>>>) list

runRenderAction :: RenderAction () a -> Hakyll a
runRenderAction action = actionFunction action ()

runRenderActionIfNeeded :: RenderAction () () -> Hakyll ()
runRenderActionIfNeeded action = do
    url <- case actionUrl action of
        (Just u) -> u
        Nothing  -> error "No url when checking dependencies."
    destination <- toDestination url
    valid <- isFileMoreRecent destination $ actionDependencies action
    unless valid $ do liftIO $ hPutStrLn stderr $ "Rendering " ++ destination
                      runRenderAction action

type Renderable = RenderAction () Context