143 lines
4.7 KiB
Haskell
Executable file
143 lines
4.7 KiB
Haskell
Executable file
-- pulling heavily from https://abhinavsarkar.net/posts/static-site-generator-using-shake/
|
|
-- docs:
|
|
-- https://hackage.haskell.org/package/shake-0.19.8/docs/doc-index-All.html
|
|
-- https://hackage.haskell.org/package/pandoc-3.2.1/docs/doc-index-All.html
|
|
-- https://hackage.haskell.org/package/mustache-2.4.2/docs/doc-index.html
|
|
--
|
|
|
|
module Main where
|
|
|
|
import Control.Monad (forM)
|
|
import Data.List (sortOn)
|
|
import Development.Shake (Action, Rules, (|%>), (~>), (%>))
|
|
import Development.Shake.FilePath ((</>))
|
|
import qualified Data.HashMap.Strict as HM
|
|
import qualified Data.Ord as Ord
|
|
import qualified Data.Text as T
|
|
import qualified Development.Shake as Shake
|
|
import qualified Development.Shake.FilePath as Shake
|
|
import Config
|
|
import Types
|
|
import Utilities
|
|
import Templates
|
|
-- target = thing we want
|
|
-- Rule = pattern of thing being made + actions to produce the thing
|
|
-- Action = actions to produce a thing
|
|
|
|
main :: IO ()
|
|
main = Shake.shakeArgs Shake.shakeOptions $ do
|
|
Shake.withTargetDocs "Build the site" $
|
|
"build" ~> buildSite
|
|
Shake.withTargetDocs "Clean the built site" $
|
|
"clean" ~> Shake.removeFilesAfter outputDir ["//*"]
|
|
Shake.withoutTargets buildRules
|
|
|
|
buildSite :: Action ()
|
|
buildSite = do
|
|
-- static files
|
|
assetPaths <- Shake.getDirectoryFiles "" assetGlobs
|
|
-- path concat each asset path so it's output into the outputDir
|
|
Shake.need $ map (outputDir </>) assetPaths
|
|
|
|
-- take the misc pages which aren't blog posts and make their html files
|
|
Shake.need $ map indexHtmlOutputPath pagePaths
|
|
|
|
-- handle posts
|
|
postPaths <- Shake.getDirectoryFiles "" postGlobs
|
|
Shake.need $ map indexHtmlOutputPath postPaths
|
|
|
|
-- remaining pages, index.xml = rss feed
|
|
Shake.need $ map (outputDir </>) ["index.html", "index.xml"]
|
|
|
|
buildRules :: Rules ()
|
|
buildRules = do
|
|
home
|
|
assets
|
|
pages
|
|
typstPostsRule
|
|
markdownPostsRule
|
|
rss
|
|
|
|
-- make a rule of the pattern outputDir/asset_name which copes from outputDir/../pages
|
|
assets :: Rules ()
|
|
assets = map (outputDir </>) assetGlobs |%> \target -> do
|
|
let src = Shake.dropDirectory1 target
|
|
Shake.copyFileChanged src target
|
|
Shake.putInfo $ "Copied " <> target <> " from " <> src
|
|
|
|
|
|
pages :: Rules ()
|
|
pages = map indexHtmlOutputPath pagePaths |%> \target -> do
|
|
let src = indexHtmlSourcePath target
|
|
let metaSrc = indexHtmlMetaPath target
|
|
html <- typstToHtml src
|
|
meta <- yamlToPost metaSrc
|
|
let page = Page (postTitle meta) html
|
|
applyTemplateAndWrite "default.html" page target
|
|
Shake.putInfo $ "Built " <> target <> " from " <> src
|
|
|
|
typstPostsRule :: Rules ()
|
|
typstPostsRule = map indexHtmlOutputPath postGlobs |%> \target -> do
|
|
let src = indexHtmlSourcePath target
|
|
post <- readTypstPost src
|
|
postHtml <- applyTemplate "post.html" post
|
|
|
|
let page = Page (postTitle post) postHtml
|
|
applyTemplateAndWrite "default.html" page target
|
|
Shake.putInfo $ "Built " <> target <> " from " <> src
|
|
|
|
markdownPostsRule :: Rules ()
|
|
markdownPostsRule = map indexHtmlOutputPath postGlobs |%> \target -> do
|
|
let src = indexHtmlSourcePath target
|
|
post <- readMarkdownPost src
|
|
postHtml <- applyTemplate "post.html" post
|
|
|
|
let page = Page (postTitle post) postHtml
|
|
applyTemplateAndWrite "default.html" page target
|
|
Shake.putInfo $ "Built " <> target <> " from " <> src
|
|
|
|
home :: Rules ()
|
|
home = outputDir </> "index.html" %> \target -> do
|
|
postPaths <- Shake.getDirectoryFiles "" postGlobs
|
|
posts <- take 3
|
|
. sortOn (Ord.Down . postDate)
|
|
<$> forM postPaths readPost
|
|
html <- applyTemplate "home.html" $ HM.singleton "posts" posts
|
|
|
|
let page = Page (T.pack "Home") html
|
|
applyTemplateAndWrite "default.html" page target
|
|
Shake.putInfo $ "Built " <> target
|
|
|
|
rss :: Rules ()
|
|
rss = outputDir </> "index.xml" %> \target -> do
|
|
postPaths <- Shake.getDirectoryFiles "" postGlobs
|
|
posts <- sortOn (Ord.Down . postDate) <$> forM postPaths readPost
|
|
applyTemplateAndWrite "feed.xml" (HM.singleton "posts" posts) target
|
|
|
|
Shake.putInfo $ "Built " <> target
|
|
|
|
readTypstPost :: FilePath -> Action Post
|
|
readTypstPost postPath = do
|
|
html <- typstToHtml postPath
|
|
post <- yamlToPost $ typstMetaPath postPath
|
|
Shake.putInfo $ "Read " <> postPath
|
|
return $ post
|
|
{
|
|
postContent = Just html,
|
|
postLink = Just . T.pack $ "/" <> Shake.dropExtension postPath <> "/"
|
|
}
|
|
|
|
readMarkdownPost :: FilePath -> Action Post
|
|
readMarkdownPost postPath = do
|
|
date <- parseTimeM False defaultTimeLocale "%Y-%-m-%-d"
|
|
. take 10
|
|
. Shake.takeBaseName
|
|
$ postPath
|
|
let formattedDate = T.pack $ formatTime @UTCTime defaultTimeLocale "%b %e, %Y" date
|
|
(post, html) <- markdownToHtml postPath
|
|
Shake.putInfo $ "Read " <> postPath
|
|
return $ post
|
|
{ postDate = Just formattedDate,
|
|
postContent = Just html,
|
|
postLink = Just . T.pack $ "/" <> Shake.dropExtension postPath <> "/"
|
|
}
|