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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
{-# LANGUAGE OverloadedStrings, RankNTypes, StandaloneDeriving, FlexibleInstances #-}
import Hakyll
import Data.Monoid (Monoid(..), mconcat, (<>))
import Control.Monad (liftM, forM_)
import Data.Char (toLower, isSpace, isAlphaNum)
import Data.Maybe (mapMaybe, fromMaybe)
import Data.Map (Map)
import qualified Data.Map as Map
import qualified Data.Set as Set
import Data.List (take, reverse, nub, groupBy, concatMap)
import Data.Function (on)
import Data.Default
import Text.Pandoc
import Text.Pandoc.Walk (query)
import Text.Pandoc.Error
import Control.Applicative (Alternative(..), Applicative(..))
import qualified Crypto.Hash.SHA256 as SHA256 (hash)
import qualified Data.ByteString.Char8 as CBS
import Data.Hex
import Data.Char (toLower)
import System.FilePath (takeBaseName, (</>), (<.>))
import Math (compileMath)
main :: IO ()
main = hakyllWith config $ do
match "templates/*" $ compile templateCompiler
match "css/*" $ do
route idRoute
compile copyFileCompiler
match "posts/*" $ do
route $ setExtension ".html"
compile $ do
getResourceBody >>= saveSnapshot "content"
pandocCompiler
>>= loadAndApplyTemplate "templates/default.html" defaultContext
>>= relativizeUrls
math <- getMath "posts/*" mathTranslation'
forM_ math $ \(deps, mathStr) ->
rulesExtraDependencies (map IdentifierDependency deps) $
create [mathTranslation' mathStr] $ do
route idRoute
compile $ do
makeItem mathStr
>>= loadAndApplyTemplate "templates/math.tex" defaultContext
>>= withItemBody (unsafeCompiler . compileMath)
tags <- buildTags "posts/*" tagTranslation' >>= addTag "All Posts" "posts/*"
tagsRules tags $ \tag pattern -> do
route idRoute
compile $ do
let ctx = mconcat [ constField "title" tag
, listField "posts" defaultContext $ chronological =<< loadAll pattern
, constField "rss" $ "/rss" </> tagTranslation tag <.> "rss"
, defaultContext
]
makeItem ""
>>= loadAndApplyTemplate "templates/post-list.html" ctx
>>= loadAndApplyTemplate "templates/default.html" ctx
>>= relativizeUrls
let
tags' = tags { tagsMakeId = fromFilePath . (\b -> "rss" </> b <.> "rss") . takeBaseName . toFilePath . tagsMakeId tags}
tagsRules tags' $ \tag pattern -> do
route idRoute
compile $ do
let
feedCtx = mconcat [ bodyField "description"
, defaultContext
]
renderRss (feedConfig tag) feedCtx =<< loadAllSnapshots pattern "content"
match "index.md" $ rulesExtraDependencies [tagsDependency tags] $ do
route $ setExtension ".html"
compile $ do
let ctx = mconcat [ listField "tags" defaultContext $ mapM (\(k, _) -> renderTag k tags) $ tagsMap tags
, constField "title" "Index"
, constField "rss" "/rss/all-posts.rss"
, defaultContext
]
item <- getResourceBody
pandocCompilerWith def (def { writerEmailObfuscation = NoObfuscation })
>>= loadAndApplyTemplate "templates/index.html" ctx
>>= loadAndApplyTemplate "templates/default.html" ctx
>>= relativizeUrls
deriving instance Eq (Item String)
feedConfig :: String -> FeedConfiguration
feedConfig tagName = FeedConfiguration { feedTitle = "dirty-haskell.org: " ++ tagName
, feedDescription = "dirty-haskell.org — A Blog."
, feedAuthorName = "G. Kleen"
, feedAuthorEmail = "blog@dirty-haskell.org"
, feedRoot = "https://dirty-haskell.org"
}
renderTag :: String -- ^ Tag name
-> Tags
-> Compiler (Item String)
renderTag tag tags = do
ellipsisItem <- makeItem ""
let
ids = fromMaybe [] $ lookup tag $ tagsMap tags
postCtx = mconcat [ listField "posts" (ellipsisContext ellipsisItem) $ liftM (withEllipsis ellipsisItem) $ chronological =<< mapM load ids
, constField "title" tag
, constField "rss" ("rss" </> tagTranslation tag <.> "rss")
, constField "url" ("tags" </> tagTranslation tag <.> "html")
, defaultContext
]
makeItem ""
>>= loadAndApplyTemplate "templates/post-list.html" postCtx
>>= loadAndApplyTemplate "templates/tag.html" postCtx
where
ellipsisContext item = mconcat [ boolField "ellipsis" (== item)
, defaultContext
]
boolField name f = field name (\i -> if f i
then pure (error $ unwords ["no string value for bool field:",name])
else empty)
withEllipsis ellipsisItem xs
| length xs > max = ellipsisItem : takeEnd (max - 1) xs
| otherwise = xs
takeEnd i = reverse . take i . reverse
max = 4
tagTranslation' :: String -> Identifier
tagTranslation' = fromCapture "tags/*.html" . tagTranslation
tagTranslation :: String -> String
tagTranslation = mapMaybe charTrans
where
charTrans c
| isSpace c = Just '-'
| isAlphaNum c = Just $ toLower c
| otherwise = Nothing
mathTranslation' :: String -> Identifier
mathTranslation' = fromCapture "math/*.svg" . map toLower . CBS.unpack . hex . SHA256.hash . CBS.pack
addTag :: MonadMetadata m => String -> Pattern -> Tags -> m Tags
addTag name pattern tags = do
ids <- getMatches pattern
return $ tags { tagsMap = tagsMap tags ++ [(name, ids)] }
getMath :: Pattern -> (String -> Identifier) -> Rules [([Identifier], String)]
getMath pattern makeId = do
ids <- getMatches pattern
mathStrs <- concat `liftM` mapM (\id -> map ((,) [id]) `liftM` getMath' (toFilePath' id)) ids
return $ mergeGroups $ groupBy ((==) `on` snd) $ mathStrs
where
getMath' :: FilePath -> Rules [String]
getMath' path = preprocess (query extractMath `liftM` readPandoc' path)
extractMath :: Inline -> [String]
extractMath (Math _ str) = [str]
extractMath _ = []
mergeGroups :: [[([Identifier], String)]] -> [([Identifier], String)]
mergeGroups = map mergeGroups' . filter (not . null)
mergeGroups' :: [([Identifier], String)] -> ([Identifier], String)
mergeGroups' xs@((_, str):_) = (concatMap fst xs, str)
readPandoc' :: FilePath -> IO Pandoc
readPandoc' path = readFile path >>= either fail return . result'
where
result' str = case result str of
Left (ParseFailure err) -> Left $
"parse failed: " ++ err
Left (ParsecError _ err) -> Left $
"parse failed: " ++ show err
Right item' -> Right item'
result str = reader defaultHakyllReaderOptions (fileType path) str
reader ro t = case t of
DocBook -> readDocBook ro
Html -> readHtml ro
LaTeX -> readLaTeX ro
LiterateHaskell t' -> reader (addExt ro Ext_literate_haskell) t'
Markdown -> readMarkdown ro
MediaWiki -> readMediaWiki ro
OrgMode -> readOrg ro
Rst -> readRST ro
Textile -> readTextile ro
_ -> error $
"I don't know how to read a file of " ++
"the type " ++ show t ++ " for: " ++ path
addExt ro e = ro {readerExtensions = Set.insert e $ readerExtensions ro}
toFilePath' :: Identifier -> FilePath
toFilePath' = (providerDirectory config </>) . toFilePath
config :: Configuration
config = defaultConfiguration { providerDirectory = "provider"
, deployCommand = "rsync -av --progress -c --delete-delay -m _site/ gkleen@surtr.yggdrasil.li:/var/www/dirty-haskell.org/"
}
|
