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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
--------------------------------------------------------------------------------
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Hakyll.Core.Compiler
( Compiler
, getIdentifier
, getRoute
, getRouteFor
, getMetadata
, getMetadataFor
, getResourceBody
, getResourceString
, getResourceLBS
, getResourceWith
, require
, requireAll
, cached
, unsafeCompiler
, debugCompiler
) where
--------------------------------------------------------------------------------
import Control.Applicative ((<$>))
import Data.Binary (Binary)
import Data.ByteString.Lazy (ByteString)
import Data.Typeable (Typeable)
import Prelude hiding (id, (.))
import System.Environment (getProgName)
--------------------------------------------------------------------------------
import Hakyll.Core.Compiler.Internal
import Hakyll.Core.Compiler.Require
import Hakyll.Core.Dependencies
import Hakyll.Core.Identifier
import Hakyll.Core.Logger as Logger
import Hakyll.Core.Metadata
import Hakyll.Core.ResourceProvider
import Hakyll.Core.Routes
import qualified Hakyll.Core.Store as Store
import Hakyll.Core.Writable
--------------------------------------------------------------------------------
-- | Get the identifier of the item that is currently being compiled
getIdentifier :: Compiler Identifier
getIdentifier = compilerIdentifier <$> compilerAsk
--------------------------------------------------------------------------------
-- | Get the route we are using for this item
getRoute :: Compiler (Maybe FilePath)
getRoute = getIdentifier >>= getRouteFor
--------------------------------------------------------------------------------
-- | Get the route for a specified item
getRouteFor :: Identifier -> Compiler (Maybe FilePath)
getRouteFor identifier = do
routes <- compilerRoutes <$> compilerAsk
return $ runRoutes routes identifier
--------------------------------------------------------------------------------
getMetadata :: Compiler Metadata
getMetadata = getIdentifier >>= getMetadataFor
--------------------------------------------------------------------------------
getMetadataFor :: Identifier -> Compiler Metadata
getMetadataFor identifier = do
provider <- compilerProvider <$> compilerAsk
compilerTellDependencies [IdentifierDependency identifier]
compilerUnsafeIO $ resourceMetadata provider identifier
--------------------------------------------------------------------------------
-- | Get the body of the underlying resource
getResourceBody :: Compiler String
getResourceBody = getResourceWith resourceBody
--------------------------------------------------------------------------------
-- | Get the resource we are compiling as a string
getResourceString :: Compiler String
getResourceString = getResourceWith $ const resourceString
--------------------------------------------------------------------------------
-- | Get the resource we are compiling as a lazy bytestring
--
getResourceLBS :: Compiler ByteString
getResourceLBS = getResourceWith $ const resourceLBS
--------------------------------------------------------------------------------
-- | Overloadable function for 'getResourceString' and 'getResourceLBS'
getResourceWith :: (ResourceProvider -> Identifier -> IO a) -> Compiler a
getResourceWith reader = do
provider <- compilerProvider <$> compilerAsk
id' <- compilerIdentifier <$> compilerAsk
let filePath = toFilePath id'
if resourceExists provider id'
then compilerUnsafeIO $ reader provider id'
else compilerThrow $ error' filePath
where
error' fp = "Hakyll.Core.Compiler.getResourceWith: resource " ++
show fp ++ " not found"
--------------------------------------------------------------------------------
cached :: (Binary a, Typeable a, Writable a)
=> String
-> Compiler a
-> Compiler a
cached name compiler = do
id' <- compilerIdentifier <$> compilerAsk
store <- compilerStore <$> compilerAsk
provider <- compilerProvider <$> compilerAsk
modified <- compilerUnsafeIO $ resourceModified provider id'
if modified
then do
x <- compiler
compilerUnsafeIO $ Store.set store [name, show id'] x
return x
else do
compilerTellCacheHits 1
x <- compilerUnsafeIO $ Store.get store [name, show id']
progName <- compilerUnsafeIO getProgName
case x of Store.Found x' -> return x'
_ -> compilerThrow (error' progName)
where
error' progName =
"Hakyll.Core.Compiler.cached: Cache corrupt! " ++
"Try running: " ++ progName ++ " clean"
--------------------------------------------------------------------------------
unsafeCompiler :: IO a -> Compiler a
unsafeCompiler = compilerUnsafeIO
--------------------------------------------------------------------------------
-- | Compiler for debugging purposes
debugCompiler :: String -> Compiler ()
debugCompiler msg = do
logger <- compilerLogger <$> compilerAsk
compilerUnsafeIO $ Logger.debug logger msg
|
