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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
|
{-# 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, intersperse)
import Data.Function (on)
import Data.Default
import Text.Pandoc
import Text.Pandoc.Walk (query, walkM)
import Text.Pandoc.Error
import Control.Applicative (Alternative(..), Applicative(..))
import Text.Blaze.Html (toHtml, toValue, (!))
import qualified Text.Blaze.Html5 as H
import qualified Text.Blaze.Html5.Attributes as A
import System.FilePath (takeBaseName, (</>), (<.>))
import qualified Crypto.Hash.SHA256 as SHA256 (hash)
import qualified Data.ByteString.Char8 as CBS
import Data.Hex (hex)
import Data.Char (toLower)
import Math (compileMath)
import Text.Printf (printf)
main :: IO ()
main = hakyllWith config $ do
match "templates/*" $ compile templateCompiler
match "css/*" $ do
route idRoute
compile copyFileCompiler
math <- getMath "posts/*" mathTranslation'
forM_ math $ \(_, mathStr) -> create [mathTranslation' mathStr] $ do
route idRoute
compile $ do
item <- makeItem mathStr
>>= loadAndApplyTemplate "templates/math.tex" defaultContext
>>= withItemBody (unsafeCompiler . compileMath)
saveSnapshot "alignment" $ fmap snd item
return $ fmap fst item
tags <- buildTags "posts/*" tagTranslation' >>= addTag "All Posts" "posts/*"
match "posts/*" $ do
route $ setExtension ".html"
compile $ do
let ctx = mconcat [ defaultContext
, dateField "published" "%F"
, tagsFieldWith getTags (\tag _ -> Just . H.li $ H.a ! A.href (toValue . toUrl $ "tags" </> tagTranslation tag <.> "html") $ toHtml tag) (mconcat . intersperse "\n") "tagList" tags
]
getResourceBody >>= saveSnapshot "content"
pandocCompilerWithTransformM defaultHakyllReaderOptions defaultHakyllWriterOptions mathTransform
>>= loadAndApplyTemplate "templates/default.html" ctx
>>= relativizeUrls
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.html" $ rulesExtraDependencies [tagsDependency tags] $ do
route idRoute -- $ 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 })
>>=-}
makeItem ""
>>= 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
addTag :: MonadMetadata m => String -> Pattern -> Tags -> m Tags
addTag name pattern tags = do
ids <- getMatches pattern
return $ tags { tagsMap = tagsMap tags ++ [(name, ids)] }
mathTranslation' :: String -> Identifier
mathTranslation' = fromCapture "math/*.svg" . map toLower . CBS.unpack . hex . SHA256.hash . CBS.pack
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}
mathTransform :: Pandoc -> Compiler Pandoc
mathTransform = walkM mathTransform'
where
mathTransform' :: Inline -> Compiler Inline
mathTransform' (Math mathType tex) = do
alignment <- loadSnapshotBody texId "alignment"
let
html = printf "<object data=\"/%s\" type=\"image/svg+xml\" style=\"vertical-align:-%s\">%s</object>"
(toFilePath texId) (alignment :: String) tex
return $ Span ("", [classOf mathType], []) [RawInline (Format "html") html]
where
texId = mathTranslation' tex
classOf DisplayMath = "display-math"
classOf InlineMath = "inline-math"
mathTransform' x = return x
toFilePath' :: Identifier -> FilePath
toFilePath' = (providerDirectory config </>) . toFilePath
config :: Configuration
config = defaultConfiguration { providerDirectory = "provider"
, deployCommand = "rsync -av --progress -c --delete-delay -m _site/ gkleen@ymir.yggdrasil.li:/srv/www/dirty-haskell.org/"
}
|
