{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE PackageImports #-}
module Yesod.Static
(
Static (..)
, Route (..)
, StaticRoute
, static
, staticDevel
, combineStylesheets'
, combineScripts'
, CombineSettings
, csStaticDir
, csCssPostProcess
, csJsPostProcess
, csCssPreProcess
, csJsPreProcess
, csCombinedFolder
, staticFiles
, staticFilesList
, staticFilesMap
, staticFilesMergeMap
, publicFiles
, base64md5
, embed
#ifdef TEST_EXPORT
, getFileListPieces
#endif
) where
import System.Directory
import qualified System.FilePath as FP
import Control.Monad
import Data.FileEmbed (embedDir)
import Yesod.Core
import Yesod.Core.Types
import Data.List (intercalate, sort)
import Language.Haskell.TH
import Language.Haskell.TH.Syntax as TH
import Crypto.Hash.Conduit (hashFile, sinkHash)
import Crypto.Hash (MD5, Digest)
import Control.Monad.Trans.State
#if MIN_VERSION_crypton(1,1,0)
import qualified "ram" Data.ByteArray as ByteArray
#else
import qualified "memory" Data.ByteArray as ByteArray
#endif
import qualified Data.ByteString.Base64
import qualified Data.ByteString.Char8 as S8
import qualified Data.ByteString.Lazy as L
import Data.Text (Text, pack)
import qualified Data.Text as T
import qualified Data.Map as M
import Data.IORef (readIORef, newIORef, writeIORef)
import Data.Char (isLower)
import Data.List (foldl')
import qualified Data.ByteString as S
import System.PosixCompat.Files (getFileStatus, modificationTime)
import System.Posix.Types (EpochTime)
import Conduit
import System.FilePath ((</>), (<.>), takeDirectory)
import qualified System.FilePath as F
import qualified Data.Text.Lazy as TL
import qualified Data.Text.Lazy.Encoding as TLE
import Data.Default
import Network.Wai (pathInfo)
import Network.Wai.Application.Static
( StaticSettings (..)
, staticApp
, webAppSettingsWithLookup
, embeddedSettings
)
import WaiAppStatic.Storage.Filesystem (ETagLookup)
newtype Static = Static StaticSettings
type StaticRoute = Route Static
static :: FilePath -> IO Static
static :: [Char] -> IO Static
static [Char]
dir = do
hashLookup <- [Char] -> IO ETagLookup
cachedETagLookup [Char]
dir
return $ Static $ webAppSettingsWithLookup dir hashLookup
staticDevel :: FilePath -> IO Static
staticDevel :: [Char] -> IO Static
staticDevel [Char]
dir = do
hashLookup <- [Char] -> IO ETagLookup
cachedETagLookupDevel [Char]
dir
return $ Static $ webAppSettingsWithLookup dir hashLookup
embed :: FilePath -> Q Exp
embed :: [Char] -> Q Exp
embed [Char]
fp = [|Static (embeddedSettings $([Char] -> Q Exp
embedDir [Char]
fp))|]
instance RenderRoute Static where
data Route Static = StaticRoute [Text] [(Text, Text)]
deriving (Route Static -> Route Static -> Bool
(Route Static -> Route Static -> Bool)
-> (Route Static -> Route Static -> Bool) -> Eq (Route Static)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Route Static -> Route Static -> Bool
== :: Route Static -> Route Static -> Bool
$c/= :: Route Static -> Route Static -> Bool
/= :: Route Static -> Route Static -> Bool
Eq, Int -> Route Static -> ShowS
[Route Static] -> ShowS
Route Static -> [Char]
(Int -> Route Static -> ShowS)
-> (Route Static -> [Char])
-> ([Route Static] -> ShowS)
-> Show (Route Static)
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Route Static -> ShowS
showsPrec :: Int -> Route Static -> ShowS
$cshow :: Route Static -> [Char]
show :: Route Static -> [Char]
$cshowList :: [Route Static] -> ShowS
showList :: [Route Static] -> ShowS
Show, ReadPrec [Route Static]
ReadPrec (Route Static)
Int -> ReadS (Route Static)
ReadS [Route Static]
(Int -> ReadS (Route Static))
-> ReadS [Route Static]
-> ReadPrec (Route Static)
-> ReadPrec [Route Static]
-> Read (Route Static)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS (Route Static)
readsPrec :: Int -> ReadS (Route Static)
$creadList :: ReadS [Route Static]
readList :: ReadS [Route Static]
$creadPrec :: ReadPrec (Route Static)
readPrec :: ReadPrec (Route Static)
$creadListPrec :: ReadPrec [Route Static]
readListPrec :: ReadPrec [Route Static]
Read)
renderRoute :: Route Static -> ([Text], [(Text, Text)])
renderRoute (StaticRoute [Text]
x [(Text, Text)]
y) = ([Text]
x, [(Text, Text)]
y)
instance ParseRoute Static where
parseRoute :: ([Text], [(Text, Text)]) -> Maybe (Route Static)
parseRoute ([Text]
x, [(Text, Text)]
y) = Route Static -> Maybe (Route Static)
forall a. a -> Maybe a
Just (Route Static -> Maybe (Route Static))
-> Route Static -> Maybe (Route Static)
forall a b. (a -> b) -> a -> b
$ [Text] -> [(Text, Text)] -> Route Static
StaticRoute [Text]
x [(Text, Text)]
y
instance YesodSubDispatch Static master where
yesodSubDispatch :: YesodSubRunnerEnv Static master -> Application
yesodSubDispatch YesodSubRunnerEnv {YesodRunnerEnv master
master -> Static
ParentRunner master
Route Static -> Route master
ysreParentRunner :: ParentRunner master
ysreGetSub :: master -> Static
ysreToParentRoute :: Route Static -> Route master
ysreParentEnv :: YesodRunnerEnv master
ysreGetSub :: forall sub parent. YesodSubRunnerEnv sub parent -> parent -> sub
ysreParentEnv :: forall sub parent.
YesodSubRunnerEnv sub parent -> YesodRunnerEnv parent
ysreParentRunner :: forall sub parent.
YesodSubRunnerEnv sub parent -> ParentRunner parent
ysreToParentRoute :: forall sub parent.
YesodSubRunnerEnv sub parent -> Route sub -> Route parent
..} Request
req =
ParentRunner master
ysreParentRunner HandlerFor master TypedContent
handlert YesodRunnerEnv master
ysreParentEnv ((Route Static -> Route master)
-> Maybe (Route Static) -> Maybe (Route master)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Route Static -> Route master
ysreToParentRoute Maybe (Route Static)
route) Request
req
where
route :: Maybe (Route Static)
route = Route Static -> Maybe (Route Static)
forall a. a -> Maybe a
Just (Route Static -> Maybe (Route Static))
-> Route Static -> Maybe (Route Static)
forall a b. (a -> b) -> a -> b
$ [Text] -> [(Text, Text)] -> Route Static
StaticRoute (Request -> [Text]
pathInfo Request
req) []
Static StaticSettings
set = master -> Static
ysreGetSub (master -> Static) -> master -> Static
forall a b. (a -> b) -> a -> b
$ YesodRunnerEnv master -> master
forall site. YesodRunnerEnv site -> site
yreSite (YesodRunnerEnv master -> master)
-> YesodRunnerEnv master -> master
forall a b. (a -> b) -> a -> b
$ YesodRunnerEnv master
ysreParentEnv
handlert :: HandlerFor master TypedContent
handlert = Application -> HandlerFor master TypedContent
forall (m :: * -> *) b. MonadHandler m => Application -> m b
sendWaiApplication (Application -> HandlerFor master TypedContent)
-> Application -> HandlerFor master TypedContent
forall a b. (a -> b) -> a -> b
$ StaticSettings -> Application
staticApp StaticSettings
set
notHidden :: FilePath -> Bool
notHidden :: [Char] -> Bool
notHidden [Char]
"tmp" = Bool
False
notHidden [Char]
s =
case [Char]
s of
Char
'.':[Char]
_ -> Bool
False
[Char]
_ -> Bool
True
getFileListPieces :: FilePath -> IO [[String]]
getFileListPieces :: [Char] -> IO [[[Char]]]
getFileListPieces = (StateT (Map [Char] [Char]) IO [[[Char]]]
-> Map [Char] [Char] -> IO [[[Char]]])
-> Map [Char] [Char]
-> StateT (Map [Char] [Char]) IO [[[Char]]]
-> IO [[[Char]]]
forall a b c. (a -> b -> c) -> b -> a -> c
flip StateT (Map [Char] [Char]) IO [[[Char]]]
-> Map [Char] [Char] -> IO [[[Char]]]
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT Map [Char] [Char]
forall k a. Map k a
M.empty (StateT (Map [Char] [Char]) IO [[[Char]]] -> IO [[[Char]]])
-> ([Char] -> StateT (Map [Char] [Char]) IO [[[Char]]])
-> [Char]
-> IO [[[Char]]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
-> ([[Char]] -> [[Char]])
-> StateT (Map [Char] [Char]) IO [[[Char]]])
-> ([[Char]] -> [[Char]])
-> [Char]
-> StateT (Map [Char] [Char]) IO [[[Char]]]
forall a b c. (a -> b -> c) -> b -> a -> c
flip [Char]
-> ([[Char]] -> [[Char]])
-> StateT (Map [Char] [Char]) IO [[[Char]]]
go [[Char]] -> [[Char]]
forall a. a -> a
id
where
go :: String
-> ([String] -> [String])
-> StateT (M.Map String String) IO [[String]]
go :: [Char]
-> ([[Char]] -> [[Char]])
-> StateT (Map [Char] [Char]) IO [[[Char]]]
go [Char]
fp [[Char]] -> [[Char]]
front = do
allContents <- IO [[Char]] -> StateT (Map [Char] [Char]) IO [[Char]]
forall a. IO a -> StateT (Map [Char] [Char]) IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [[Char]] -> StateT (Map [Char] [Char]) IO [[Char]])
-> IO [[Char]] -> StateT (Map [Char] [Char]) IO [[Char]]
forall a b. (a -> b) -> a -> b
$ ([[Char]] -> [[Char]]
forall a. Ord a => [a] -> [a]
sort ([[Char]] -> [[Char]])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
filter [Char] -> Bool
notHidden) ([[Char]] -> [[Char]]) -> IO [[Char]] -> IO [[Char]]
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` [Char] -> IO [[Char]]
getDirectoryContents [Char]
fp
let fullPath :: String -> String
fullPath [Char]
f = [Char]
fp [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Char
'/' Char -> ShowS
forall a. a -> [a] -> [a]
: [Char]
f
files <- liftIO $ filterM (doesFileExist . fullPath) allContents
let files' = ([Char] -> [[Char]]) -> [[Char]] -> [[[Char]]]
forall a b. (a -> b) -> [a] -> [b]
map ([[Char]] -> [[Char]]
front ([[Char]] -> [[Char]])
-> ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return) [[Char]]
files
files'' <- mapM dedupe files'
dirs <- liftIO $ filterM (doesDirectoryExist . fullPath) allContents
dirs' <- mapM (\[Char]
f -> [Char]
-> ([[Char]] -> [[Char]])
-> StateT (Map [Char] [Char]) IO [[[Char]]]
go (ShowS
fullPath [Char]
f) ([[Char]] -> [[Char]]
front ([[Char]] -> [[Char]])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (:) [Char]
f)) dirs
return $ concat $ files'' : dirs'
dedupe :: [String] -> StateT (M.Map String String) IO [String]
dedupe :: [[Char]] -> StateT (Map [Char] [Char]) IO [[Char]]
dedupe = ([Char] -> StateT (Map [Char] [Char]) IO [Char])
-> [[Char]] -> StateT (Map [Char] [Char]) IO [[Char]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM [Char] -> StateT (Map [Char] [Char]) IO [Char]
dedupe'
dedupe' :: String -> StateT (M.Map String String) IO String
dedupe' :: [Char] -> StateT (Map [Char] [Char]) IO [Char]
dedupe' [Char]
s = do
m <- StateT (Map [Char] [Char]) IO (Map [Char] [Char])
forall (m :: * -> *) s. Monad m => StateT s m s
get
case M.lookup s m of
Just [Char]
s' -> [Char] -> StateT (Map [Char] [Char]) IO [Char]
forall a. a -> StateT (Map [Char] [Char]) IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
s'
Maybe [Char]
Nothing -> do
Map [Char] [Char] -> StateT (Map [Char] [Char]) IO ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put (Map [Char] [Char] -> StateT (Map [Char] [Char]) IO ())
-> Map [Char] [Char] -> StateT (Map [Char] [Char]) IO ()
forall a b. (a -> b) -> a -> b
$ [Char] -> [Char] -> Map [Char] [Char] -> Map [Char] [Char]
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert [Char]
s [Char]
s Map [Char] [Char]
m
[Char] -> StateT (Map [Char] [Char]) IO [Char]
forall a. a -> StateT (Map [Char] [Char]) IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
s
staticFiles :: FilePath -> Q [Dec]
staticFiles :: [Char] -> Q [Dec]
staticFiles [Char]
dir = [Char] -> Q [Dec]
mkStaticFiles [Char]
dir
staticFilesList :: FilePath -> [FilePath] -> Q [Dec]
staticFilesList :: [Char] -> [[Char]] -> Q [Dec]
staticFilesList [Char]
dir [[Char]]
fs =
[Char] -> [[[Char]]] -> Bool -> Q [Dec]
mkStaticFilesList [Char]
dir (([Char] -> [[Char]]) -> [[Char]] -> [[[Char]]]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> [[Char]]
split [[Char]]
fs) Bool
True
where
split :: FilePath -> [String]
split :: [Char] -> [[Char]]
split [] = []
split [Char]
x =
let ([Char]
a, [Char]
b) = (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'/') [Char]
x
in [Char]
a [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [Char] -> [[Char]]
split (Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 [Char]
b)
publicFiles :: FilePath -> Q [Dec]
publicFiles :: [Char] -> Q [Dec]
publicFiles [Char]
dir = [Char] -> Bool -> Q [Dec]
mkStaticFiles' [Char]
dir Bool
False
staticFilesMap :: FilePath -> M.Map FilePath FilePath -> Q [Dec]
staticFilesMap :: [Char] -> Map [Char] [Char] -> Q [Dec]
staticFilesMap [Char]
fp Map [Char] [Char]
m = [Char] -> [([[Char]], [[Char]])] -> Bool -> Q [Dec]
mkStaticFilesList' [Char]
fp ((([Char], [Char]) -> ([[Char]], [[Char]]))
-> [([Char], [Char])] -> [([[Char]], [[Char]])]
forall a b. (a -> b) -> [a] -> [b]
map ([Char], [Char]) -> ([[Char]], [[Char]])
splitBoth [([Char], [Char])]
mapList) Bool
True
where
splitBoth :: ([Char], [Char]) -> ([[Char]], [[Char]])
splitBoth ([Char]
k, [Char]
v) = ([Char] -> [[Char]]
split [Char]
k, [Char] -> [[Char]]
split [Char]
v)
mapList :: [([Char], [Char])]
mapList = Map [Char] [Char] -> [([Char], [Char])]
forall k a. Map k a -> [(k, a)]
M.toList Map [Char] [Char]
m
split :: FilePath -> [String]
split :: [Char] -> [[Char]]
split [] = []
split [Char]
x =
let ([Char]
a, [Char]
b) = (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'/') [Char]
x
in [Char]
a [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [Char] -> [[Char]]
split (Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 [Char]
b)
staticFilesMergeMap :: FilePath -> M.Map FilePath FilePath -> Q [Dec]
staticFilesMergeMap :: [Char] -> Map [Char] [Char] -> Q [Dec]
staticFilesMergeMap [Char]
fp Map [Char] [Char]
m = do
fs <- IO [[[Char]]] -> Q [[[Char]]]
forall a. IO a -> Q a
forall (m :: * -> *) a. Quasi m => IO a -> m a
qRunIO (IO [[[Char]]] -> Q [[[Char]]]) -> IO [[[Char]]] -> Q [[[Char]]]
forall a b. (a -> b) -> a -> b
$ [Char] -> IO [[[Char]]]
getFileListPieces [Char]
fp
let filesList = ([[Char]] -> [Char]) -> [[[Char]]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map [[Char]] -> [Char]
FP.joinPath [[[Char]]]
fs
mergedMapList = Map [Char] [Char] -> [([Char], [Char])]
forall k a. Map k a -> [(k, a)]
M.toList (Map [Char] [Char] -> [([Char], [Char])])
-> Map [Char] [Char] -> [([Char], [Char])]
forall a b. (a -> b) -> a -> b
$ (Map [Char] [Char] -> [Char] -> Map [Char] [Char])
-> Map [Char] [Char] -> [[Char]] -> Map [Char] [Char]
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (Map [Char] [Char]
-> Map [Char] [Char] -> [Char] -> Map [Char] [Char]
checkedInsert Map [Char] [Char]
invertedMap) Map [Char] [Char]
m [[Char]]
filesList
mkStaticFilesList' fp (map splitBoth mergedMapList) True
where
splitBoth :: ([Char], [Char]) -> ([[Char]], [[Char]])
splitBoth ([Char]
k, [Char]
v) = ([Char] -> [[Char]]
split [Char]
k, [Char] -> [[Char]]
split [Char]
v)
swap :: (b, a) -> (a, b)
swap (b
x, a
y) = (a
y, b
x)
mapList :: [([Char], [Char])]
mapList = Map [Char] [Char] -> [([Char], [Char])]
forall k a. Map k a -> [(k, a)]
M.toList Map [Char] [Char]
m
invertedMap :: Map [Char] [Char]
invertedMap = [([Char], [Char])] -> Map [Char] [Char]
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([([Char], [Char])] -> Map [Char] [Char])
-> [([Char], [Char])] -> Map [Char] [Char]
forall a b. (a -> b) -> a -> b
$ (([Char], [Char]) -> ([Char], [Char]))
-> [([Char], [Char])] -> [([Char], [Char])]
forall a b. (a -> b) -> [a] -> [b]
map ([Char], [Char]) -> ([Char], [Char])
forall {b} {a}. (b, a) -> (a, b)
swap [([Char], [Char])]
mapList
split :: FilePath -> [String]
split :: [Char] -> [[Char]]
split [] = []
split [Char]
x =
let ([Char]
a, [Char]
b) = (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'/') [Char]
x
in [Char]
a [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: [Char] -> [[Char]]
split (Int -> ShowS
forall a. Int -> [a] -> [a]
drop Int
1 [Char]
b)
checkedInsert
:: M.Map FilePath FilePath
-> M.Map FilePath FilePath
-> FilePath
-> M.Map FilePath FilePath
checkedInsert :: Map [Char] [Char]
-> Map [Char] [Char] -> [Char] -> Map [Char] [Char]
checkedInsert Map [Char] [Char]
iDict Map [Char] [Char]
st [Char]
p = if [Char] -> Map [Char] [Char] -> Bool
forall k a. Ord k => k -> Map k a -> Bool
M.member [Char]
p Map [Char] [Char]
iDict
then Map [Char] [Char]
st
else [Char] -> [Char] -> Map [Char] [Char] -> Map [Char] [Char]
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert [Char]
p [Char]
p Map [Char] [Char]
st
mkHashMap :: FilePath -> IO (M.Map FilePath S8.ByteString)
mkHashMap :: [Char] -> IO (Map [Char] ByteString)
mkHashMap [Char]
dir = do
fs <- [Char] -> IO [[[Char]]]
getFileListPieces [Char]
dir
hashAlist fs >>= return . M.fromList
where
hashAlist :: [[String]] -> IO [(FilePath, S8.ByteString)]
hashAlist :: [[[Char]]] -> IO [([Char], ByteString)]
hashAlist [[[Char]]]
fs = ([[Char]] -> IO ([Char], ByteString))
-> [[[Char]]] -> IO [([Char], ByteString)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM [[Char]] -> IO ([Char], ByteString)
hashPair [[[Char]]]
fs
where
hashPair :: [String] -> IO (FilePath, S8.ByteString)
hashPair :: [[Char]] -> IO ([Char], ByteString)
hashPair [[Char]]
pieces = do let file :: [Char]
file = [Char] -> [[Char]] -> [Char]
pathFromRawPieces [Char]
dir [[Char]]
pieces
h <- [Char] -> IO [Char]
base64md5File [Char]
file
return (file, S8.pack h)
pathFromRawPieces :: FilePath -> [String] -> FilePath
pathFromRawPieces :: [Char] -> [[Char]] -> [Char]
pathFromRawPieces =
([Char] -> ShowS) -> [Char] -> [[Char]] -> [Char]
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' [Char] -> ShowS
append
where
append :: [Char] -> ShowS
append [Char]
a [Char]
b = [Char]
a [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Char
'/' Char -> ShowS
forall a. a -> [a] -> [a]
: [Char]
b
cachedETagLookupDevel :: FilePath -> IO ETagLookup
cachedETagLookupDevel :: [Char] -> IO ETagLookup
cachedETagLookupDevel [Char]
dir = do
etags <- [Char] -> IO (Map [Char] ByteString)
mkHashMap [Char]
dir
mtimeVar <- newIORef (M.empty :: M.Map FilePath EpochTime)
return $ \[Char]
f ->
case [Char] -> Map [Char] ByteString -> Maybe ByteString
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup [Char]
f Map [Char] ByteString
etags of
Maybe ByteString
Nothing -> Maybe ByteString -> IO (Maybe ByteString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ByteString
forall a. Maybe a
Nothing
Just ByteString
checksum -> do
fs <- [Char] -> IO FileStatus
getFileStatus [Char]
f
let newt = FileStatus -> CTime
modificationTime FileStatus
fs
mtimes <- readIORef mtimeVar
oldt <- case M.lookup f mtimes of
Maybe CTime
Nothing -> IORef (Map [Char] CTime) -> Map [Char] CTime -> IO ()
forall a. IORef a -> a -> IO ()
writeIORef IORef (Map [Char] CTime)
mtimeVar ([Char] -> CTime -> Map [Char] CTime -> Map [Char] CTime
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert [Char]
f CTime
newt Map [Char] CTime
mtimes) IO () -> IO CTime -> IO CTime
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> CTime -> IO CTime
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CTime
newt
Just CTime
oldt -> CTime -> IO CTime
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CTime
oldt
return $ if newt /= oldt then Nothing else Just checksum
cachedETagLookup :: FilePath -> IO ETagLookup
cachedETagLookup :: [Char] -> IO ETagLookup
cachedETagLookup [Char]
dir = do
etags <- [Char] -> IO (Map [Char] ByteString)
mkHashMap [Char]
dir
return $ (\[Char]
f -> Maybe ByteString -> IO (Maybe ByteString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe ByteString -> IO (Maybe ByteString))
-> Maybe ByteString -> IO (Maybe ByteString)
forall a b. (a -> b) -> a -> b
$ [Char] -> Map [Char] ByteString -> Maybe ByteString
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup [Char]
f Map [Char] ByteString
etags)
mkStaticFiles :: FilePath -> Q [Dec]
mkStaticFiles :: [Char] -> Q [Dec]
mkStaticFiles [Char]
fp = [Char] -> Bool -> Q [Dec]
mkStaticFiles' [Char]
fp Bool
True
mkStaticFiles' :: FilePath
-> Bool
-> Q [Dec]
mkStaticFiles' :: [Char] -> Bool -> Q [Dec]
mkStaticFiles' [Char]
fp Bool
makeHash = do
fs <- IO [[[Char]]] -> Q [[[Char]]]
forall a. IO a -> Q a
forall (m :: * -> *) a. Quasi m => IO a -> m a
qRunIO (IO [[[Char]]] -> Q [[[Char]]]) -> IO [[[Char]]] -> Q [[[Char]]]
forall a b. (a -> b) -> a -> b
$ [Char] -> IO [[[Char]]]
getFileListPieces [Char]
fp
mkStaticFilesList fp fs makeHash
mkStaticFilesList
:: FilePath
-> [[String]]
-> Bool
-> Q [Dec]
mkStaticFilesList :: [Char] -> [[[Char]]] -> Bool -> Q [Dec]
mkStaticFilesList [Char]
fp [[[Char]]]
fs Bool
makeHash = [Char] -> [([[Char]], [[Char]])] -> Bool -> Q [Dec]
mkStaticFilesList' [Char]
fp ([[[Char]]] -> [[[Char]]] -> [([[Char]], [[Char]])]
forall a b. [a] -> [b] -> [(a, b)]
zip [[[Char]]]
fs [[[Char]]]
fs) Bool
makeHash
mkStaticFilesList'
:: FilePath
-> [([String], [String])]
-> Bool
-> Q [Dec]
mkStaticFilesList' :: [Char] -> [([[Char]], [[Char]])] -> Bool -> Q [Dec]
mkStaticFilesList' [Char]
fp [([[Char]], [[Char]])]
fs Bool
makeHash = do
[[Dec]] -> [Dec]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Dec]] -> [Dec]) -> Q [[Dec]] -> Q [Dec]
forall a b. (a -> b) -> Q a -> Q b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` (([[Char]], [[Char]]) -> Q [Dec])
-> [([[Char]], [[Char]])] -> Q [[Dec]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ([[Char]], [[Char]]) -> Q [Dec]
mkRoute [([[Char]], [[Char]])]
fs
where
replace' :: Char -> Char
replace' Char
c
| Char
'A' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'Z' = Char
c
| Char
'a' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'z' = Char
c
| Char
'0' Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
c Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Char
'9' = Char
c
| Bool
otherwise = Char
'_'
mkRoute :: ([[Char]], [[Char]]) -> Q [Dec]
mkRoute ([[Char]]
alias, [[Char]]
f) = do
let name' :: [Char]
name' = [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
"_" ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$ ShowS -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ((Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
replace') [[Char]]
alias
routeName :: Name
routeName = [Char] -> Name
mkName ([Char] -> Name) -> [Char] -> Name
forall a b. (a -> b) -> a -> b
$
case [Char]
name' of
[] -> ShowS
forall a. HasCallStack => [Char] -> a
error [Char]
"null-named file"
Char
n : [Char]
_
| Char -> Bool
isLower Char
n -> [Char]
name'
| Bool
otherwise -> Char
'_' Char -> ShowS
forall a. a -> [a] -> [a]
: [Char]
name'
f' <- [|map pack $([[Char]] -> Q Exp
forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
forall (m :: * -> *). Quote m => [[Char]] -> m Exp
TH.lift [[Char]]
f)|]
qs <- if makeHash
then do hash <- qRunIO $ base64md5File $ pathFromRawPieces fp f
[|[(pack "etag", pack $(TH.lift hash))]|]
else return $ ListE []
return
[ SigD routeName $ ConT ''StaticRoute
, FunD routeName
[ Clause [] (NormalB $ (ConE 'StaticRoute) `AppE` f' `AppE` qs) []
]
]
base64md5File :: FilePath -> IO String
base64md5File :: [Char] -> IO [Char]
base64md5File = (Digest MD5 -> [Char]) -> IO (Digest MD5) -> IO [Char]
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ByteString -> [Char]
base64 (ByteString -> [Char])
-> (Digest MD5 -> ByteString) -> Digest MD5 -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Digest MD5 -> ByteString
forall {bout}. ByteArray bout => Digest MD5 -> bout
encode) (IO (Digest MD5) -> IO [Char])
-> ([Char] -> IO (Digest MD5)) -> [Char] -> IO [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> IO (Digest MD5)
forall (m :: * -> *) hash.
(MonadIO m, HashAlgorithm hash) =>
[Char] -> m (Digest hash)
hashFile
where encode :: Digest MD5 -> bout
encode Digest MD5
d = Digest MD5 -> bout
forall bin bout.
(ByteArrayAccess bin, ByteArray bout) =>
bin -> bout
ByteArray.convert (Digest MD5
d :: Digest MD5)
base64md5 :: L.ByteString -> String
base64md5 :: ByteString -> [Char]
base64md5 ByteString
lbs =
ByteString -> [Char]
base64 (ByteString -> [Char]) -> ByteString -> [Char]
forall a b. (a -> b) -> a -> b
$ Digest MD5 -> ByteString
forall {bout}. ByteArray bout => Digest MD5 -> bout
encode
(Digest MD5 -> ByteString) -> Digest MD5 -> ByteString
forall a b. (a -> b) -> a -> b
$ ConduitT () Void Identity (Digest MD5) -> Digest MD5
forall r. ConduitT () Void Identity r -> r
runConduitPure
(ConduitT () Void Identity (Digest MD5) -> Digest MD5)
-> ConduitT () Void Identity (Digest MD5) -> Digest MD5
forall a b. (a -> b) -> a -> b
$ ByteString -> ConduitT () ByteString Identity ()
forall (m :: * -> *) lazy strict i.
(Monad m, LazySequence lazy strict) =>
lazy -> ConduitT i strict m ()
Conduit.sourceLazy ByteString
lbs ConduitT () ByteString Identity ()
-> ConduitT ByteString Void Identity (Digest MD5)
-> ConduitT () Void Identity (Digest MD5)
forall (m :: * -> *) a b c r.
Monad m =>
ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
.| ConduitT ByteString Void Identity (Digest MD5)
forall (m :: * -> *) hash o.
(Monad m, HashAlgorithm hash) =>
ConduitT ByteString o m (Digest hash)
sinkHash
where
encode :: Digest MD5 -> bout
encode Digest MD5
d = Digest MD5 -> bout
forall bin bout.
(ByteArrayAccess bin, ByteArray bout) =>
bin -> bout
ByteArray.convert (Digest MD5
d :: Digest MD5)
base64 :: S.ByteString -> String
base64 :: ByteString -> [Char]
base64 = (Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
tr
ShowS -> (ByteString -> [Char]) -> ByteString -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ShowS
forall a. Int -> [a] -> [a]
take Int
8
ShowS -> (ByteString -> [Char]) -> ByteString -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Char]
S8.unpack
(ByteString -> [Char])
-> (ByteString -> ByteString) -> ByteString -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
Data.ByteString.Base64.encode
where
tr :: Char -> Char
tr Char
'+' = Char
'-'
tr Char
'/' = Char
'_'
tr Char
c = Char
c
data CombineType = JS | CSS
combineStatics' :: CombineType
-> CombineSettings
-> [Route Static]
-> Q Exp
combineStatics' :: CombineType -> CombineSettings -> [Route Static] -> Q Exp
combineStatics' CombineType
combineType CombineSettings {[Char]
[[Char]] -> ByteString -> IO ByteString
Text -> IO Text
csStaticDir :: CombineSettings -> [Char]
csCssPostProcess :: CombineSettings -> [[Char]] -> ByteString -> IO ByteString
csJsPostProcess :: CombineSettings -> [[Char]] -> ByteString -> IO ByteString
csCssPreProcess :: CombineSettings -> Text -> IO Text
csJsPreProcess :: CombineSettings -> Text -> IO Text
csCombinedFolder :: CombineSettings -> [Char]
csStaticDir :: [Char]
csCssPostProcess :: [[Char]] -> ByteString -> IO ByteString
csJsPostProcess :: [[Char]] -> ByteString -> IO ByteString
csCssPreProcess :: Text -> IO Text
csJsPreProcess :: Text -> IO Text
csCombinedFolder :: [Char]
..} [Route Static]
routes = do
texts <- IO Text -> Q Text
forall a. IO a -> Q a
forall (m :: * -> *) a. Quasi m => IO a -> m a
qRunIO (IO Text -> Q Text) -> IO Text -> Q Text
forall a b. (a -> b) -> a -> b
$ ConduitT () Void (ResourceT IO) Text -> IO Text
forall (m :: * -> *) r.
MonadUnliftIO m =>
ConduitT () Void (ResourceT m) r -> m r
runConduitRes
(ConduitT () Void (ResourceT IO) Text -> IO Text)
-> ConduitT () Void (ResourceT IO) Text -> IO Text
forall a b. (a -> b) -> a -> b
$ [[Char]] -> ConduitT () (Element [[Char]]) (ResourceT IO) ()
forall (m :: * -> *) mono i.
(Monad m, MonoFoldable mono) =>
mono -> ConduitT i (Element mono) m ()
yieldMany [[Char]]
fps
ConduitT () [Char] (ResourceT IO) ()
-> ConduitT [Char] Void (ResourceT IO) Text
-> ConduitT () Void (ResourceT IO) Text
forall (m :: * -> *) a b c r.
Monad m =>
ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
.| ([Char] -> ConduitT [Char] Text (ResourceT IO) ())
-> ConduitT [Char] Text (ResourceT IO) ()
forall (m :: * -> *) i o r.
Monad m =>
(i -> ConduitT i o m r) -> ConduitT i o m ()
awaitForever [Char] -> ConduitT [Char] Text (ResourceT IO) ()
forall {m :: * -> *} {a}.
(MonadResource m, MonadThrow m) =>
[Char] -> ConduitT a Text m ()
readUTFFile
ConduitT [Char] Text (ResourceT IO) ()
-> ConduitT Text Void (ResourceT IO) Text
-> ConduitT [Char] Void (ResourceT IO) Text
forall (m :: * -> *) a b c r.
Monad m =>
ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
.| ConduitT Text Void (ResourceT IO) Text
forall (m :: * -> *) lazy strict o.
(Monad m, LazySequence lazy strict) =>
ConduitT strict o m lazy
sinkLazy
ltext <- qRunIO $ preProcess texts
bs <- qRunIO $ postProcess fps $ TLE.encodeUtf8 ltext
let hash' = ByteString -> [Char]
base64md5 ByteString
bs
suffix = [Char]
csCombinedFolder [Char] -> ShowS
</> [Char]
hash' [Char] -> ShowS
<.> [Char]
extension
fp = [Char]
csStaticDir [Char] -> ShowS
</> [Char]
suffix
qRunIO $ do
createDirectoryIfMissing True $ takeDirectory fp
L.writeFile fp bs
let pieces = (Text -> [Char]) -> [Text] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map Text -> [Char]
T.unpack ([Text] -> [[Char]]) -> [Text] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ HasCallStack => Text -> Text -> [Text]
Text -> Text -> [Text]
T.splitOn Text
"/" (Text -> [Text]) -> Text -> [Text]
forall a b. (a -> b) -> a -> b
$ [Char] -> Text
T.pack [Char]
suffix
[|StaticRoute (map pack pieces) []|]
where
fps :: [FilePath]
fps :: [[Char]]
fps = (Route Static -> [Char]) -> [Route Static] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map Route Static -> [Char]
toFP [Route Static]
routes
toFP :: Route Static -> [Char]
toFP (StaticRoute [Text]
pieces [(Text, Text)]
_) = [Char]
csStaticDir [Char] -> ShowS
</> [[Char]] -> [Char]
F.joinPath ((Text -> [Char]) -> [Text] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map Text -> [Char]
T.unpack [Text]
pieces)
readUTFFile :: [Char] -> ConduitT a Text m ()
readUTFFile [Char]
fp = [Char] -> ConduitT a ByteString m ()
forall (m :: * -> *) i.
MonadResource m =>
[Char] -> ConduitT i ByteString m ()
sourceFile [Char]
fp ConduitT a ByteString m ()
-> ConduitT ByteString Text m () -> ConduitT a Text m ()
forall (m :: * -> *) a b c r.
Monad m =>
ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
.| ConduitT ByteString Text m ()
forall (m :: * -> *). MonadThrow m => ConduitT ByteString Text m ()
decodeUtf8C
postProcess :: [[Char]] -> ByteString -> IO ByteString
postProcess =
case CombineType
combineType of
CombineType
JS -> [[Char]] -> ByteString -> IO ByteString
csJsPostProcess
CombineType
CSS -> [[Char]] -> ByteString -> IO ByteString
csCssPostProcess
preProcess :: Text -> IO Text
preProcess =
case CombineType
combineType of
CombineType
JS -> Text -> IO Text
csJsPreProcess
CombineType
CSS -> Text -> IO Text
csCssPreProcess
extension :: [Char]
extension =
case CombineType
combineType of
CombineType
JS -> [Char]
"js"
CombineType
CSS -> [Char]
"css"
data CombineSettings = CombineSettings
{ CombineSettings -> [Char]
csStaticDir :: FilePath
, CombineSettings -> [[Char]] -> ByteString -> IO ByteString
csCssPostProcess :: [FilePath] -> L.ByteString -> IO L.ByteString
, CombineSettings -> [[Char]] -> ByteString -> IO ByteString
csJsPostProcess :: [FilePath] -> L.ByteString -> IO L.ByteString
, CombineSettings -> Text -> IO Text
csCssPreProcess :: TL.Text -> IO TL.Text
, CombineSettings -> Text -> IO Text
csJsPreProcess :: TL.Text -> IO TL.Text
, CombineSettings -> [Char]
csCombinedFolder :: FilePath
}
instance Default CombineSettings where
def :: CombineSettings
def = CombineSettings
{ csStaticDir :: [Char]
csStaticDir = [Char]
"static"
, csCssPostProcess :: [[Char]] -> ByteString -> IO ByteString
csCssPostProcess = (ByteString -> IO ByteString)
-> [[Char]] -> ByteString -> IO ByteString
forall a b. a -> b -> a
const ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
, csJsPostProcess :: [[Char]] -> ByteString -> IO ByteString
csJsPostProcess = (ByteString -> IO ByteString)
-> [[Char]] -> ByteString -> IO ByteString
forall a b. a -> b -> a
const ByteString -> IO ByteString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
, csCssPreProcess :: Text -> IO Text
csCssPreProcess =
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
(Text -> IO Text) -> (Text -> Text) -> Text -> IO Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => Text -> Text -> Text -> Text
Text -> Text -> Text -> Text
TL.replace Text
"'/static/" Text
"'../"
(Text -> Text) -> (Text -> Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => Text -> Text -> Text -> Text
Text -> Text -> Text -> Text
TL.replace Text
"\"/static/" Text
"\"../"
, csJsPreProcess :: Text -> IO Text
csJsPreProcess = Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return
, csCombinedFolder :: [Char]
csCombinedFolder = [Char]
"combined"
}
liftRoutes :: [Route Static] -> Q Exp
liftRoutes :: [Route Static] -> Q Exp
liftRoutes =
([Exp] -> Exp) -> Q [Exp] -> Q Exp
forall a b. (a -> b) -> Q a -> Q b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Exp] -> Exp
ListE (Q [Exp] -> Q Exp)
-> ([Route Static] -> Q [Exp]) -> [Route Static] -> Q Exp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Route Static -> Q Exp) -> [Route Static] -> Q [Exp]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Route Static -> Q Exp
go
where
go :: Route Static -> Q Exp
go :: Route Static -> Q Exp
go (StaticRoute [Text]
x [(Text, Text)]
y) = [|StaticRoute $([Text] -> Q Exp
liftTexts [Text]
x) $([(Text, Text)] -> Q Exp
liftPairs [(Text, Text)]
y)|]
liftTexts :: [Text] -> Q Exp
liftTexts = ([Exp] -> Exp) -> Q [Exp] -> Q Exp
forall a b. (a -> b) -> Q a -> Q b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Exp] -> Exp
ListE (Q [Exp] -> Q Exp) -> ([Text] -> Q [Exp]) -> [Text] -> Q Exp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Q Exp) -> [Text] -> Q [Exp]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Text -> Q Exp
forall {m :: * -> *}. Quote m => Text -> m Exp
liftT
liftT :: Text -> m Exp
liftT Text
t = [|pack $([Char] -> m Exp
forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
forall (m :: * -> *). Quote m => [Char] -> m Exp
TH.lift ([Char] -> m Exp) -> [Char] -> m Exp
forall a b. (a -> b) -> a -> b
$ Text -> [Char]
T.unpack Text
t)|]
liftPairs :: [(Text, Text)] -> Q Exp
liftPairs = ([Exp] -> Exp) -> Q [Exp] -> Q Exp
forall a b. (a -> b) -> Q a -> Q b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Exp] -> Exp
ListE (Q [Exp] -> Q Exp)
-> ([(Text, Text)] -> Q [Exp]) -> [(Text, Text)] -> Q Exp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Text, Text) -> Q Exp) -> [(Text, Text)] -> Q [Exp]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (Text, Text) -> Q Exp
forall {m :: * -> *}. Quote m => (Text, Text) -> m Exp
liftPair
liftPair :: (Text, Text) -> m Exp
liftPair (Text
x, Text
y) = [|($(Text -> m Exp
forall {m :: * -> *}. Quote m => Text -> m Exp
liftT Text
x), $(Text -> m Exp
forall {m :: * -> *}. Quote m => Text -> m Exp
liftT Text
y))|]
combineStylesheets' :: Bool
-> CombineSettings
-> Name
-> [Route Static]
-> Q Exp
combineStylesheets' :: Bool -> CombineSettings -> Name -> [Route Static] -> Q Exp
combineStylesheets' Bool
development CombineSettings
cs Name
con [Route Static]
routes
| Bool
development = [| mapM_ (addStylesheet . $(Exp -> Q Exp
forall a. a -> Q a
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> Q Exp) -> Exp -> Q Exp
forall a b. (a -> b) -> a -> b
$ Name -> Exp
ConE Name
con)) $([Route Static] -> Q Exp
liftRoutes [Route Static]
routes) |]
| Bool
otherwise = [| addStylesheet $ $(Exp -> Q Exp
forall a. a -> Q a
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> Q Exp) -> Exp -> Q Exp
forall a b. (a -> b) -> a -> b
$ Name -> Exp
ConE Name
con) $(CombineType -> CombineSettings -> [Route Static] -> Q Exp
combineStatics' CombineType
CSS CombineSettings
cs [Route Static]
routes) |]
combineScripts' :: Bool
-> CombineSettings
-> Name
-> [Route Static]
-> Q Exp
combineScripts' :: Bool -> CombineSettings -> Name -> [Route Static] -> Q Exp
combineScripts' Bool
development CombineSettings
cs Name
con [Route Static]
routes
| Bool
development = [| mapM_ (addScript . $(Exp -> Q Exp
forall a. a -> Q a
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> Q Exp) -> Exp -> Q Exp
forall a b. (a -> b) -> a -> b
$ Name -> Exp
ConE Name
con)) $([Route Static] -> Q Exp
liftRoutes [Route Static]
routes) |]
| Bool
otherwise = [| addScript $ $(Exp -> Q Exp
forall a. a -> Q a
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> Q Exp) -> Exp -> Q Exp
forall a b. (a -> b) -> a -> b
$ Name -> Exp
ConE Name
con) $(CombineType -> CombineSettings -> [Route Static] -> Q Exp
combineStatics' CombineType
JS CombineSettings
cs [Route Static]
routes) |]