{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveLift #-}
{-# OPTIONS_GHC -fno-warn-missing-fields #-}
{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
module Text.Shakespeare
( ShakespeareSettings (..)
, PreConvert (..)
, WrapInsertion (..)
, PreConversion (..)
, defaultShakespeareSettings
, shakespeare
, shakespeareFile
, shakespeareFileReload
, shakespeareFromString
, shakespeareUsedIdentifiers
, RenderUrl
, VarType (..)
, Deref
, Parser
, preFilter
, shakespeareRuntime
, pack'
) where
import Data.List (intersperse)
import Data.Char (isAlphaNum, isSpace)
import Text.ParserCombinators.Parsec hiding (Line, parse, Parser)
import Text.Parsec.Prim (modifyState, Parsec)
import Language.Haskell.TH.Quote (QuasiQuoter (..))
import Language.Haskell.TH (appE)
import Language.Haskell.TH.Lift ()
import Language.Haskell.TH.Syntax
import Data.Text.Lazy.Builder (Builder, fromText)
#if !MIN_VERSION_base(4,11,0)
import Data.Monoid
#endif
import System.IO.Unsafe (unsafePerformIO)
import qualified Data.Text as TS
import Text.Shakespeare.Base
import System.Directory (getModificationTime)
import Data.Time (UTCTime)
import Data.IORef
import qualified Data.Map as M
import GHC.Generics (Generic)
import Data.Typeable (Typeable)
import Data.Data (Data)
import System.Process (readProcessWithExitCode)
import System.Exit (ExitCode(..))
type Parser = Parsec String [String]
parse :: GenParser tok [a1] a -> SourceName -> [tok] -> Either ParseError a
parse :: forall tok a1 a.
GenParser tok [a1] a -> [Char] -> [tok] -> Either ParseError a
parse GenParser tok [a1] a
p = GenParser tok [a1] a
-> [a1] -> [Char] -> [tok] -> Either ParseError a
forall tok st a.
GenParser tok st a -> st -> [Char] -> [tok] -> Either ParseError a
runParser GenParser tok [a1] a
p []
data PreConvert = PreConvert
{ PreConvert -> PreConversion
preConvert :: PreConversion
, PreConvert -> [Char]
preEscapeIgnoreBalanced :: [Char]
, PreConvert -> [Char]
preEscapeIgnoreLine :: [Char]
, PreConvert -> Maybe WrapInsertion
wrapInsertion :: Maybe WrapInsertion
}
deriving (forall (m :: * -> *). Quote m => PreConvert -> m Exp)
-> (forall (m :: * -> *).
Quote m =>
PreConvert -> Code m PreConvert)
-> Lift PreConvert
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => PreConvert -> m Exp
forall (m :: * -> *). Quote m => PreConvert -> Code m PreConvert
$clift :: forall (m :: * -> *). Quote m => PreConvert -> m Exp
lift :: forall (m :: * -> *). Quote m => PreConvert -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => PreConvert -> Code m PreConvert
liftTyped :: forall (m :: * -> *). Quote m => PreConvert -> Code m PreConvert
Lift
data WrapInsertion = WrapInsertion {
WrapInsertion -> Maybe [Char]
wrapInsertionIndent :: Maybe String
, WrapInsertion -> [Char]
wrapInsertionStartBegin :: String
, WrapInsertion -> [Char]
wrapInsertionSeparator :: String
, WrapInsertion -> [Char]
wrapInsertionStartClose :: String
, WrapInsertion -> [Char]
wrapInsertionEnd :: String
, WrapInsertion -> Bool
wrapInsertionAddParens :: Bool
}
deriving (forall (m :: * -> *). Quote m => WrapInsertion -> m Exp)
-> (forall (m :: * -> *).
Quote m =>
WrapInsertion -> Code m WrapInsertion)
-> Lift WrapInsertion
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => WrapInsertion -> m Exp
forall (m :: * -> *).
Quote m =>
WrapInsertion -> Code m WrapInsertion
$clift :: forall (m :: * -> *). Quote m => WrapInsertion -> m Exp
lift :: forall (m :: * -> *). Quote m => WrapInsertion -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
WrapInsertion -> Code m WrapInsertion
liftTyped :: forall (m :: * -> *).
Quote m =>
WrapInsertion -> Code m WrapInsertion
Lift
data PreConversion = ReadProcess String [String]
| Id
deriving (forall (m :: * -> *). Quote m => PreConversion -> m Exp)
-> (forall (m :: * -> *).
Quote m =>
PreConversion -> Code m PreConversion)
-> Lift PreConversion
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => PreConversion -> m Exp
forall (m :: * -> *).
Quote m =>
PreConversion -> Code m PreConversion
$clift :: forall (m :: * -> *). Quote m => PreConversion -> m Exp
lift :: forall (m :: * -> *). Quote m => PreConversion -> m Exp
$cliftTyped :: forall (m :: * -> *).
Quote m =>
PreConversion -> Code m PreConversion
liftTyped :: forall (m :: * -> *).
Quote m =>
PreConversion -> Code m PreConversion
Lift
data ShakespeareSettings = ShakespeareSettings
{ ShakespeareSettings -> Char
varChar :: Char
, ShakespeareSettings -> Char
urlChar :: Char
, ShakespeareSettings -> Char
intChar :: Char
, ShakespeareSettings -> Exp
toBuilder :: Exp
, ShakespeareSettings -> Exp
wrap :: Exp
, ShakespeareSettings -> Exp
unwrap :: Exp
, ShakespeareSettings -> Bool
justVarInterpolation :: Bool
, ShakespeareSettings -> Maybe PreConvert
preConversion :: Maybe PreConvert
, ShakespeareSettings -> Maybe Exp
modifyFinalValue :: Maybe Exp
}
defaultShakespeareSettings :: ShakespeareSettings
defaultShakespeareSettings :: ShakespeareSettings
defaultShakespeareSettings = ShakespeareSettings {
varChar :: Char
varChar = Char
'#'
, urlChar :: Char
urlChar = Char
'@'
, intChar :: Char
intChar = Char
'^'
, justVarInterpolation :: Bool
justVarInterpolation = Bool
False
, preConversion :: Maybe PreConvert
preConversion = Maybe PreConvert
forall a. Maybe a
Nothing
, modifyFinalValue :: Maybe Exp
modifyFinalValue = Maybe Exp
forall a. Maybe a
Nothing
}
instance Lift ShakespeareSettings where
lift :: forall (m :: * -> *). Quote m => ShakespeareSettings -> m Exp
lift (ShakespeareSettings Char
x1 Char
x2 Char
x3 Exp
x4 Exp
x5 Exp
x6 Bool
x7 Maybe PreConvert
x8 Maybe Exp
x9) =
[|ShakespeareSettings
$(Char -> m Exp
forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
forall (m :: * -> *). Quote m => Char -> m Exp
lift Char
x1) $(Char -> m Exp
forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
forall (m :: * -> *). Quote m => Char -> m Exp
lift Char
x2) $(Char -> m Exp
forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
forall (m :: * -> *). Quote m => Char -> m Exp
lift Char
x3)
$(Exp -> m Exp
forall {m :: * -> *}. Quote m => Exp -> m Exp
liftExp Exp
x4) $(Exp -> m Exp
forall {m :: * -> *}. Quote m => Exp -> m Exp
liftExp Exp
x5) $(Exp -> m Exp
forall {m :: * -> *}. Quote m => Exp -> m Exp
liftExp Exp
x6) $(Bool -> m Exp
forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
forall (m :: * -> *). Quote m => Bool -> m Exp
lift Bool
x7) $(Maybe PreConvert -> m Exp
forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
forall (m :: * -> *). Quote m => Maybe PreConvert -> m Exp
lift Maybe PreConvert
x8) $(Maybe Exp -> m Exp
forall {m :: * -> *}. Quote m => Maybe Exp -> m Exp
liftMExp Maybe Exp
x9)|]
where
liftExp :: Exp -> m Exp
liftExp (VarE Name
n) = [|VarE $(Name -> m Exp
forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
forall (m :: * -> *). Quote m => Name -> m Exp
lift Name
n)|]
liftExp (ConE Name
n) = [|ConE $(Name -> m Exp
forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
forall (m :: * -> *). Quote m => Name -> m Exp
lift Name
n)|]
liftExp Exp
_ = [Char] -> m Exp
forall a. HasCallStack => [Char] -> a
error [Char]
"liftExp only supports VarE and ConE"
liftMExp :: Maybe Exp -> m Exp
liftMExp Maybe Exp
Nothing = [|Nothing|]
liftMExp (Just Exp
e) = [|Just|] m Exp -> m Exp -> m Exp
forall (m :: * -> *). Quote m => m Exp -> m Exp -> m Exp
`appE` Exp -> m Exp
forall {m :: * -> *}. Quote m => Exp -> m Exp
liftExp Exp
e
#if MIN_VERSION_template_haskell(2,17,0)
liftTyped :: forall (m :: * -> *).
Quote m =>
ShakespeareSettings -> Code m ShakespeareSettings
liftTyped = m Exp -> Code m ShakespeareSettings
forall a (m :: * -> *). Quote m => m Exp -> Code m a
unsafeCodeCoerce (m Exp -> Code m ShakespeareSettings)
-> (ShakespeareSettings -> m Exp)
-> ShakespeareSettings
-> Code m ShakespeareSettings
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShakespeareSettings -> m Exp
forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
forall (m :: * -> *). Quote m => ShakespeareSettings -> m Exp
lift
#elif MIN_VERSION_template_haskell(2,16,0)
liftTyped = unsafeTExpCoerce . lift
#endif
type QueryParameters = [(TS.Text, TS.Text)]
type RenderUrl url = (url -> QueryParameters -> TS.Text)
type Shakespeare url = RenderUrl url -> Builder
data Content = ContentRaw String
| ContentVar Deref
| ContentUrl Deref
| ContentUrlParam Deref
| ContentMix Deref
deriving (Int -> Content -> ShowS
[Content] -> ShowS
Content -> [Char]
(Int -> Content -> ShowS)
-> (Content -> [Char]) -> ([Content] -> ShowS) -> Show Content
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Content -> ShowS
showsPrec :: Int -> Content -> ShowS
$cshow :: Content -> [Char]
show :: Content -> [Char]
$cshowList :: [Content] -> ShowS
showList :: [Content] -> ShowS
Show, Content -> Content -> Bool
(Content -> Content -> Bool)
-> (Content -> Content -> Bool) -> Eq Content
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Content -> Content -> Bool
== :: Content -> Content -> Bool
$c/= :: Content -> Content -> Bool
/= :: Content -> Content -> Bool
Eq)
type Contents = [Content]
eShowErrors :: Either ParseError c -> c
eShowErrors :: forall c. Either ParseError c -> c
eShowErrors = (ParseError -> c) -> (c -> c) -> Either ParseError c -> c
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either ([Char] -> c
forall a. HasCallStack => [Char] -> a
error ([Char] -> c) -> (ParseError -> [Char]) -> ParseError -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError -> [Char]
forall a. Show a => a -> [Char]
show) c -> c
forall a. a -> a
id
contentFromString :: ShakespeareSettings -> String -> [Content]
contentFromString :: ShakespeareSettings -> [Char] -> [Content]
contentFromString ShakespeareSettings
_ [Char]
"" = []
contentFromString ShakespeareSettings
rs [Char]
s =
[Content] -> [Content]
compressContents ([Content] -> [Content]) -> [Content] -> [Content]
forall a b. (a -> b) -> a -> b
$ Either ParseError [Content] -> [Content]
forall c. Either ParseError c -> c
eShowErrors (Either ParseError [Content] -> [Content])
-> Either ParseError [Content] -> [Content]
forall a b. (a -> b) -> a -> b
$ GenParser Char [[Char]] [Content]
-> [Char] -> [Char] -> Either ParseError [Content]
forall tok a1 a.
GenParser tok [a1] a -> [Char] -> [tok] -> Either ParseError a
parse (ShakespeareSettings -> GenParser Char [[Char]] [Content]
parseContents ShakespeareSettings
rs) [Char]
s [Char]
s
where
compressContents :: Contents -> Contents
compressContents :: [Content] -> [Content]
compressContents [] = []
compressContents (ContentRaw [Char]
x:ContentRaw [Char]
y:[Content]
z) =
[Content] -> [Content]
compressContents ([Content] -> [Content]) -> [Content] -> [Content]
forall a b. (a -> b) -> a -> b
$ [Char] -> Content
ContentRaw ([Char]
x [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
y) Content -> [Content] -> [Content]
forall a. a -> [a] -> [a]
: [Content]
z
compressContents (Content
x:[Content]
y) = Content
x Content -> [Content] -> [Content]
forall a. a -> [a] -> [a]
: [Content] -> [Content]
compressContents [Content]
y
parseContents :: ShakespeareSettings -> Parser Contents
parseContents :: ShakespeareSettings -> GenParser Char [[Char]] [Content]
parseContents = ParsecT [Char] [[Char]] Identity Content
-> GenParser Char [[Char]] [Content]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many1 (ParsecT [Char] [[Char]] Identity Content
-> GenParser Char [[Char]] [Content])
-> (ShakespeareSettings
-> ParsecT [Char] [[Char]] Identity Content)
-> ShakespeareSettings
-> GenParser Char [[Char]] [Content]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShakespeareSettings -> ParsecT [Char] [[Char]] Identity Content
parseContent
where
parseContent :: ShakespeareSettings -> Parser Content
parseContent :: ShakespeareSettings -> ParsecT [Char] [[Char]] Identity Content
parseContent ShakespeareSettings {Bool
Char
Maybe Exp
Maybe PreConvert
Exp
varChar :: ShakespeareSettings -> Char
urlChar :: ShakespeareSettings -> Char
intChar :: ShakespeareSettings -> Char
toBuilder :: ShakespeareSettings -> Exp
wrap :: ShakespeareSettings -> Exp
unwrap :: ShakespeareSettings -> Exp
justVarInterpolation :: ShakespeareSettings -> Bool
preConversion :: ShakespeareSettings -> Maybe PreConvert
modifyFinalValue :: ShakespeareSettings -> Maybe Exp
varChar :: Char
urlChar :: Char
intChar :: Char
toBuilder :: Exp
wrap :: Exp
unwrap :: Exp
justVarInterpolation :: Bool
preConversion :: Maybe PreConvert
modifyFinalValue :: Maybe Exp
..} =
ParsecT [Char] [[Char]] Identity Content
forall {a}. ParsecT [Char] a Identity Content
parseVar' ParsecT [Char] [[Char]] Identity Content
-> ParsecT [Char] [[Char]] Identity Content
-> ParsecT [Char] [[Char]] Identity Content
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Char] [[Char]] Identity Content
forall {a}. ParsecT [Char] a Identity Content
parseUrl' ParsecT [Char] [[Char]] Identity Content
-> ParsecT [Char] [[Char]] Identity Content
-> ParsecT [Char] [[Char]] Identity Content
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Char] [[Char]] Identity Content
forall {a}. ParsecT [Char] a Identity Content
parseInt' ParsecT [Char] [[Char]] Identity Content
-> ParsecT [Char] [[Char]] Identity Content
-> ParsecT [Char] [[Char]] Identity Content
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT [Char] [[Char]] Identity Content
forall {a}. ParsecT [Char] a Identity Content
parseChar'
where
parseVar' :: ParsecT [Char] a Identity Content
parseVar' = ([Char] -> Content)
-> (Deref -> Content) -> Either [Char] Deref -> Content
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either [Char] -> Content
ContentRaw Deref -> Content
ContentVar (Either [Char] Deref -> Content)
-> ParsecT [Char] a Identity (Either [Char] Deref)
-> ParsecT [Char] a Identity Content
forall a b.
(a -> b)
-> ParsecT [Char] a Identity a -> ParsecT [Char] a Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Char -> ParsecT [Char] a Identity (Either [Char] Deref)
forall a. Char -> UserParser a (Either [Char] Deref)
parseVar Char
varChar
parseUrl' :: ParsecT [Char] a Identity Content
parseUrl' = ([Char] -> Content)
-> ((Deref, Bool) -> Content)
-> Either [Char] (Deref, Bool)
-> Content
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either [Char] -> Content
ContentRaw (Deref, Bool) -> Content
contentUrl (Either [Char] (Deref, Bool) -> Content)
-> ParsecT [Char] a Identity (Either [Char] (Deref, Bool))
-> ParsecT [Char] a Identity Content
forall a b.
(a -> b)
-> ParsecT [Char] a Identity a -> ParsecT [Char] a Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Char
-> Char -> ParsecT [Char] a Identity (Either [Char] (Deref, Bool))
forall a.
Char -> Char -> UserParser a (Either [Char] (Deref, Bool))
parseUrl Char
urlChar Char
'?'
where
contentUrl :: (Deref, Bool) -> Content
contentUrl (Deref
d, Bool
False) = Deref -> Content
ContentUrl Deref
d
contentUrl (Deref
d, Bool
True) = Deref -> Content
ContentUrlParam Deref
d
parseInt' :: ParsecT [Char] a Identity Content
parseInt' = ([Char] -> Content)
-> (Deref -> Content) -> Either [Char] Deref -> Content
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either [Char] -> Content
ContentRaw Deref -> Content
ContentMix (Either [Char] Deref -> Content)
-> ParsecT [Char] a Identity (Either [Char] Deref)
-> ParsecT [Char] a Identity Content
forall a b.
(a -> b)
-> ParsecT [Char] a Identity a -> ParsecT [Char] a Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Char -> ParsecT [Char] a Identity (Either [Char] Deref)
forall a. Char -> UserParser a (Either [Char] Deref)
parseInt Char
intChar
parseChar' :: ParsecT [Char] u Identity Content
parseChar' = [Char] -> Content
ContentRaw ([Char] -> Content)
-> ParsecT [Char] u Identity [Char]
-> ParsecT [Char] u Identity Content
forall a b.
(a -> b)
-> ParsecT [Char] u Identity a -> ParsecT [Char] u Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` ParsecT [Char] u Identity Char -> ParsecT [Char] u Identity [Char]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many1 ([Char] -> ParsecT [Char] u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m Char
noneOf [Char
varChar, Char
urlChar, Char
intChar])
readProcessError :: FilePath -> [String] -> String
-> Maybe FilePath
-> IO String
readProcessError :: [Char] -> [[Char]] -> [Char] -> Maybe [Char] -> IO [Char]
readProcessError [Char]
cmd [[Char]]
args [Char]
input Maybe [Char]
mfp = do
(ex, output, err) <- [Char] -> [[Char]] -> [Char] -> IO (ExitCode, [Char], [Char])
readProcessWithExitCode [Char]
cmd [[Char]]
args [Char]
input
case ex of
ExitCode
ExitSuccess ->
case [Char]
err of
[] -> [Char] -> IO [Char]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
output
[Char]
msg -> [Char] -> IO [Char]
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO [Char]) -> [Char] -> IO [Char]
forall a b. (a -> b) -> a -> b
$ [Char]
"stderr received during readProcess:" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
displayCmd [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"\n\n" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
msg
ExitFailure Int
r ->
[Char] -> IO [Char]
forall a. HasCallStack => [Char] -> a
error ([Char] -> IO [Char]) -> [Char] -> IO [Char]
forall a b. (a -> b) -> a -> b
$ [Char]
"exit code " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
r [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" from readProcess: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
displayCmd [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"\n\n"
[Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"stderr:\n" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
err
where
displayCmd :: [Char]
displayCmd = [Char]
cmd [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Char
' 'Char -> ShowS
forall a. a -> [a] -> [a]
:[[Char]] -> [Char]
unwords (ShowS -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ShowS
forall a. Show a => a -> [Char]
show [[Char]]
args) [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++
case Maybe [Char]
mfp of
Maybe [Char]
Nothing -> [Char]
""
Just [Char]
fp -> Char
' 'Char -> ShowS
forall a. a -> [a] -> [a]
:[Char]
fp
preFilter :: Maybe FilePath
-> ShakespeareSettings
-> String
-> IO String
preFilter :: Maybe [Char] -> ShakespeareSettings -> [Char] -> IO [Char]
preFilter Maybe [Char]
mfp ShakespeareSettings {Bool
Char
Maybe Exp
Maybe PreConvert
Exp
varChar :: ShakespeareSettings -> Char
urlChar :: ShakespeareSettings -> Char
intChar :: ShakespeareSettings -> Char
toBuilder :: ShakespeareSettings -> Exp
wrap :: ShakespeareSettings -> Exp
unwrap :: ShakespeareSettings -> Exp
justVarInterpolation :: ShakespeareSettings -> Bool
preConversion :: ShakespeareSettings -> Maybe PreConvert
modifyFinalValue :: ShakespeareSettings -> Maybe Exp
varChar :: Char
urlChar :: Char
intChar :: Char
toBuilder :: Exp
wrap :: Exp
unwrap :: Exp
justVarInterpolation :: Bool
preConversion :: Maybe PreConvert
modifyFinalValue :: Maybe Exp
..} [Char]
template =
case Maybe PreConvert
preConversion of
Maybe PreConvert
Nothing -> [Char] -> IO [Char]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
template
Just pre :: PreConvert
pre@(PreConvert PreConversion
convert [Char]
_ [Char]
_ Maybe WrapInsertion
mWrapI) ->
if (Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isSpace [Char]
template then [Char] -> IO [Char]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
template else
let ([[Char]]
groups, [[Char]]
rvars) = Either ParseError ([[Char]], [[Char]]) -> ([[Char]], [[Char]])
forall c. Either ParseError c -> c
eShowErrors (Either ParseError ([[Char]], [[Char]]) -> ([[Char]], [[Char]]))
-> Either ParseError ([[Char]], [[Char]]) -> ([[Char]], [[Char]])
forall a b. (a -> b) -> a -> b
$ GenParser Char [[Char]] ([[Char]], [[Char]])
-> [Char] -> [Char] -> Either ParseError ([[Char]], [[Char]])
forall tok a1 a.
GenParser tok [a1] a -> [Char] -> [tok] -> Either ParseError a
parse
(Maybe WrapInsertion
-> PreConvert -> GenParser Char [[Char]] ([[Char]], [[Char]])
forall {a}.
Maybe a
-> PreConvert -> GenParser Char [[Char]] ([[Char]], [[Char]])
parseConvertWrapInsertion Maybe WrapInsertion
mWrapI PreConvert
pre)
[Char]
template
[Char]
template
vars :: [[Char]]
vars = [[Char]] -> [[Char]]
forall a. [a] -> [a]
reverse [[Char]]
rvars
parsed :: [Char]
parsed = [[Char]] -> [Char]
forall a. Monoid a => [a] -> a
mconcat [[Char]]
groups
withVars :: [Char]
withVars = (Maybe WrapInsertion -> [[Char]] -> ShowS
addVars Maybe WrapInsertion
mWrapI [[Char]]
vars [Char]
parsed)
in Maybe WrapInsertion -> [[Char]] -> ShowS
applyVars Maybe WrapInsertion
mWrapI [[Char]]
vars ShowS -> 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` case PreConversion
convert of
PreConversion
Id -> [Char] -> IO [Char]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
withVars
ReadProcess [Char]
command [[Char]]
args ->
[Char] -> [[Char]] -> [Char] -> Maybe [Char] -> IO [Char]
readProcessError [Char]
command [[Char]]
args [Char]
withVars Maybe [Char]
mfp
where
addIndent :: Maybe String -> String -> String
addIndent :: Maybe [Char] -> ShowS
addIndent Maybe [Char]
Nothing [Char]
str = [Char]
str
addIndent (Just [Char]
indent) [Char]
str = ShowS -> ShowS
mapLines (\[Char]
line -> [Char]
indent [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
line) [Char]
str
where
mapLines :: ShowS -> ShowS
mapLines ShowS
f = [[Char]] -> [Char]
unlines ([[Char]] -> [Char]) -> ([Char] -> [[Char]]) -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ShowS
f ([[Char]] -> [[Char]])
-> ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
lines
shakespeare_prefix :: [Char]
shakespeare_prefix = [Char]
"shakespeare_var_"
shakespeare_var_conversion :: ShowS
shakespeare_var_conversion (Char
'@':Char
'?':Char
'{':[Char]
str) = ShowS
shakespeare_var_conversion (Char
'@'Char -> ShowS
forall a. a -> [a] -> [a]
:Char
'{'Char -> ShowS
forall a. a -> [a] -> [a]
:[Char]
str)
shakespeare_var_conversion (Char
_:Char
'{':[Char]
str) = [Char]
shakespeare_prefix [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> (Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
filter Char -> Bool
isAlphaNum (ShowS
forall a. HasCallStack => [a] -> [a]
init [Char]
str)
shakespeare_var_conversion [Char]
err = ShowS
forall a. HasCallStack => [Char] -> a
error ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$ [Char]
"did not expect: " [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
err
applyVars :: Maybe WrapInsertion -> [[Char]] -> ShowS
applyVars Maybe WrapInsertion
_ [] [Char]
str = [Char]
str
applyVars Maybe WrapInsertion
Nothing [[Char]]
_ [Char]
str = [Char]
str
applyVars (Just WrapInsertion {Bool
[Char]
Maybe [Char]
wrapInsertionIndent :: WrapInsertion -> Maybe [Char]
wrapInsertionStartBegin :: WrapInsertion -> [Char]
wrapInsertionSeparator :: WrapInsertion -> [Char]
wrapInsertionStartClose :: WrapInsertion -> [Char]
wrapInsertionEnd :: WrapInsertion -> [Char]
wrapInsertionAddParens :: WrapInsertion -> Bool
wrapInsertionIndent :: Maybe [Char]
wrapInsertionStartBegin :: [Char]
wrapInsertionSeparator :: [Char]
wrapInsertionStartClose :: [Char]
wrapInsertionEnd :: [Char]
wrapInsertionAddParens :: Bool
..}) [[Char]]
vars [Char]
str =
(if Bool
wrapInsertionAddParens then [Char]
"(" else [Char]
"")
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
removeTrailingSemiColon
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> (if Bool
wrapInsertionAddParens then [Char]
")" else [Char]
"")
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
"("
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [[Char]] -> [Char]
forall a. Monoid a => [a] -> a
mconcat ([Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
intersperse [Char]
", " [[Char]]
vars)
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
");\n"
where
removeTrailingSemiColon :: [Char]
removeTrailingSemiColon = ShowS
forall a. [a] -> [a]
reverse ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
(Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (\Char
c -> Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
';' Bool -> Bool -> Bool
|| Char -> Bool
isSpace Char
c) (ShowS
forall a. [a] -> [a]
reverse [Char]
str)
addVars :: Maybe WrapInsertion -> [[Char]] -> ShowS
addVars Maybe WrapInsertion
_ [] [Char]
str = [Char]
str
addVars Maybe WrapInsertion
Nothing [[Char]]
_ [Char]
str = [Char]
str
addVars (Just WrapInsertion {Bool
[Char]
Maybe [Char]
wrapInsertionIndent :: WrapInsertion -> Maybe [Char]
wrapInsertionStartBegin :: WrapInsertion -> [Char]
wrapInsertionSeparator :: WrapInsertion -> [Char]
wrapInsertionStartClose :: WrapInsertion -> [Char]
wrapInsertionEnd :: WrapInsertion -> [Char]
wrapInsertionAddParens :: WrapInsertion -> Bool
wrapInsertionIndent :: Maybe [Char]
wrapInsertionStartBegin :: [Char]
wrapInsertionSeparator :: [Char]
wrapInsertionStartClose :: [Char]
wrapInsertionEnd :: [Char]
wrapInsertionAddParens :: Bool
..}) [[Char]]
vars [Char]
str =
[Char]
wrapInsertionStartBegin
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [[Char]] -> [Char]
forall a. Monoid a => [a] -> a
mconcat ([Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
intersperse [Char]
wrapInsertionSeparator ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ ShowS -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map ShowS
shakespeare_var_conversion [[Char]]
vars)
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
wrapInsertionStartClose
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> Maybe [Char] -> ShowS
addIndent Maybe [Char]
wrapInsertionIndent [Char]
str
[Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<> [Char]
wrapInsertionEnd
parseConvertWrapInsertion :: Maybe a
-> PreConvert -> GenParser Char [[Char]] ([[Char]], [[Char]])
parseConvertWrapInsertion Maybe a
Nothing = ShowS -> PreConvert -> GenParser Char [[Char]] ([[Char]], [[Char]])
parseConvert ShowS
forall a. a -> a
id
parseConvertWrapInsertion (Just a
_) = ShowS -> PreConvert -> GenParser Char [[Char]] ([[Char]], [[Char]])
parseConvert ShowS
shakespeare_var_conversion
parseConvert :: ShowS -> PreConvert -> GenParser Char [[Char]] ([[Char]], [[Char]])
parseConvert ShowS
varConvert PreConvert {[Char]
Maybe WrapInsertion
PreConversion
preConvert :: PreConvert -> PreConversion
preEscapeIgnoreBalanced :: PreConvert -> [Char]
preEscapeIgnoreLine :: PreConvert -> [Char]
wrapInsertion :: PreConvert -> Maybe WrapInsertion
preConvert :: PreConversion
preEscapeIgnoreBalanced :: [Char]
preEscapeIgnoreLine :: [Char]
wrapInsertion :: Maybe WrapInsertion
..} = do
str <- ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [[Char]]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many1 (ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [[Char]])
-> ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [[Char]]
forall a b. (a -> b) -> a -> b
$ [ParsecT [Char] [[Char]] Identity [Char]]
-> ParsecT [Char] [[Char]] Identity [Char]
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice ([ParsecT [Char] [[Char]] Identity [Char]]
-> ParsecT [Char] [[Char]] Identity [Char])
-> [ParsecT [Char] [[Char]] Identity [Char]]
-> ParsecT [Char] [[Char]] Identity [Char]
forall a b. (a -> b) -> a -> b
$
(Char -> ParsecT [Char] [[Char]] Identity [Char])
-> [Char] -> [ParsecT [Char] [[Char]] Identity [Char]]
forall a b. (a -> b) -> [a] -> [b]
map (ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [Char]
forall tok st a. GenParser tok st a -> GenParser tok st a
try (ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [Char])
-> (Char -> ParsecT [Char] [[Char]] Identity [Char])
-> Char
-> ParsecT [Char] [[Char]] Identity [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ParsecT [Char] [[Char]] Identity [Char]
forall {s} {m :: * -> *} {u}.
Stream s m Char =>
Char -> ParsecT s u m [Char]
escapedParse) [Char]
preEscapeIgnoreBalanced [ParsecT [Char] [[Char]] Identity [Char]]
-> [ParsecT [Char] [[Char]] Identity [Char]]
-> [ParsecT [Char] [[Char]] Identity [Char]]
forall a. [a] -> [a] -> [a]
++ [ParsecT [Char] [[Char]] Identity [Char]
mainParser]
st <- getState
return (str, st)
where
escapedParse :: Char -> ParsecT s u m [Char]
escapedParse Char
ignoreC = do
_<- Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
ignoreC
inside <- many $ noneOf [ignoreC]
_<- char ignoreC
return $ ignoreC:inside ++ [ignoreC]
mainParser :: ParsecT [Char] [[Char]] Identity [Char]
mainParser =
ParsecT [Char] [[Char]] Identity [Char]
parseVar' ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [Char]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
ParsecT [Char] [[Char]] Identity [Char]
parseUrl' ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [Char]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
ParsecT [Char] [[Char]] Identity [Char]
parseInt' ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [Char]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
[Char] -> ParsecT [Char] [[Char]] Identity [Char]
forall {s} {m :: * -> *} {u}.
Stream s m Char =>
[Char] -> ParsecT s u m [Char]
parseCommentLine [Char]
preEscapeIgnoreLine ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [Char]
-> ParsecT [Char] [[Char]] Identity [Char]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
[Char] -> [Char] -> ParsecT [Char] [[Char]] Identity [Char]
forall {s} {m :: * -> *} {u}.
Stream s m Char =>
[Char] -> [Char] -> ParsecT s u m [Char]
parseChar' [Char]
preEscapeIgnoreLine [Char]
preEscapeIgnoreBalanced
recordRight :: Either [Char] [Char] -> ParsecT s [[Char]] m [Char]
recordRight (Left [Char]
str) = [Char] -> ParsecT s [[Char]] m [Char]
forall a. a -> ParsecT s [[Char]] m a
forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
str
recordRight (Right [Char]
str) = ([[Char]] -> [[Char]]) -> ParsecT s [[Char]] m ()
forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
modifyState (\[[Char]]
vars -> [Char]
str[Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
:[[Char]]
vars) ParsecT s [[Char]] m ()
-> ParsecT s [[Char]] m [Char] -> ParsecT s [[Char]] m [Char]
forall a b.
ParsecT s [[Char]] m a
-> ParsecT s [[Char]] m b -> ParsecT s [[Char]] m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> ParsecT s [[Char]] m [Char]
forall a. a -> ParsecT s [[Char]] m a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShowS
varConvert [Char]
str)
newLine :: [Char]
newLine = [Char]
"\r\n"
parseCommentLine :: [Char] -> ParsecT s u m [Char]
parseCommentLine [Char]
cs = do
begin <- [Char] -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m Char
oneOf [Char]
cs
comment <- many $ noneOf newLine
return $ begin : comment
parseVar' :: (Parsec String [String]) String
parseVar' :: ParsecT [Char] [[Char]] Identity [Char]
parseVar' = Either [Char] [Char] -> ParsecT [Char] [[Char]] Identity [Char]
forall {m :: * -> *} {s}.
Monad m =>
Either [Char] [Char] -> ParsecT s [[Char]] m [Char]
recordRight (Either [Char] [Char] -> ParsecT [Char] [[Char]] Identity [Char])
-> ParsecT [Char] [[Char]] Identity (Either [Char] [Char])
-> ParsecT [Char] [[Char]] Identity [Char]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Char -> ParsecT [Char] [[Char]] Identity (Either [Char] [Char])
forall a. Char -> UserParser a (Either [Char] [Char])
parseVarString Char
varChar
parseUrl' :: ParsecT [Char] [[Char]] Identity [Char]
parseUrl' = Either [Char] [Char] -> ParsecT [Char] [[Char]] Identity [Char]
forall {m :: * -> *} {s}.
Monad m =>
Either [Char] [Char] -> ParsecT s [[Char]] m [Char]
recordRight (Either [Char] [Char] -> ParsecT [Char] [[Char]] Identity [Char])
-> ParsecT [Char] [[Char]] Identity (Either [Char] [Char])
-> ParsecT [Char] [[Char]] Identity [Char]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Char
-> Char -> ParsecT [Char] [[Char]] Identity (Either [Char] [Char])
forall a. Char -> Char -> UserParser a (Either [Char] [Char])
parseUrlString Char
urlChar Char
'?'
parseInt' :: ParsecT [Char] [[Char]] Identity [Char]
parseInt' = Either [Char] [Char] -> ParsecT [Char] [[Char]] Identity [Char]
forall {m :: * -> *} {s}.
Monad m =>
Either [Char] [Char] -> ParsecT s [[Char]] m [Char]
recordRight (Either [Char] [Char] -> ParsecT [Char] [[Char]] Identity [Char])
-> ParsecT [Char] [[Char]] Identity (Either [Char] [Char])
-> ParsecT [Char] [[Char]] Identity [Char]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Char -> ParsecT [Char] [[Char]] Identity (Either [Char] [Char])
forall a. Char -> UserParser a (Either [Char] [Char])
parseIntString Char
intChar
parseChar' :: [Char] -> [Char] -> ParsecT s u m [Char]
parseChar' [Char]
comments [Char]
ignores =
ParsecT s u m Char -> ParsecT s u m [Char]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many1 ([Char] -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
[Char] -> ParsecT s u m Char
noneOf ([Char
varChar, Char
urlChar, Char
intChar] [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
comments [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
ignores))
pack' :: String -> TS.Text
pack' :: [Char] -> Text
pack' = [Char] -> Text
TS.pack
contentsToShakespeare :: ShakespeareSettings -> [Content] -> Q Exp
contentsToShakespeare :: ShakespeareSettings -> [Content] -> Q Exp
contentsToShakespeare ShakespeareSettings
rs [Content]
a = do
r <- [Char] -> Q Name
forall (m :: * -> *). Quote m => [Char] -> m Name
newName [Char]
"_render"
c <- mapM (contentToBuilder r) a
compiledTemplate <- case c of
[] -> (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 -> Exp
AppE (Exp -> Exp -> Exp) -> Exp -> Exp -> Exp
forall a b. (a -> b) -> a -> b
$ ShakespeareSettings -> Exp
wrap ShakespeareSettings
rs) [|mempty|]
[Exp
x] -> Exp -> Q Exp
forall a. a -> Q a
forall (m :: * -> *) a. Monad m => a -> m a
return Exp
x
[Exp]
_ -> do
mc <- [|mconcat|]
return $ mc `AppE` ListE c
fmap (maybe id AppE $ modifyFinalValue rs) $ return $
if justVarInterpolation rs
then compiledTemplate
else LamE [VarP r] compiledTemplate
where
contentToBuilder :: Name -> Content -> Q Exp
contentToBuilder :: Name -> Content -> Q Exp
contentToBuilder Name
_ (ContentRaw [Char]
s') = do
ts <- [|fromText . pack'|]
return $ wrap rs `AppE` (ts `AppE` LitE (StringL s'))
contentToBuilder Name
_ (ContentVar Deref
d) =
Exp -> Q Exp
forall a. a -> Q a
forall (m :: * -> *) a. Monad m => a -> m a
return (ShakespeareSettings -> Exp
toBuilder ShakespeareSettings
rs Exp -> Exp -> Exp
`AppE` Scope -> Deref -> Exp
derefToExp [] Deref
d)
contentToBuilder Name
r (ContentUrl Deref
d) = do
ts <- [|fromText|]
return $ wrap rs `AppE` (ts `AppE` (VarE r `AppE` derefToExp [] d `AppE` ListE []))
contentToBuilder Name
r (ContentUrlParam Deref
d) = do
ts <- [|fromText|]
up <- [|\r' (u, p) -> r' u p|]
return $ wrap rs `AppE` (ts `AppE` (up `AppE` VarE r `AppE` derefToExp [] d))
contentToBuilder Name
r (ContentMix Deref
d) =
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
$
if ShakespeareSettings -> Bool
justVarInterpolation ShakespeareSettings
rs
then Scope -> Deref -> Exp
derefToExp [] Deref
d
else Scope -> Deref -> Exp
derefToExp [] Deref
d Exp -> Exp -> Exp
`AppE` Name -> Exp
VarE Name
r
shakespeare :: ShakespeareSettings -> QuasiQuoter
shakespeare :: ShakespeareSettings -> QuasiQuoter
shakespeare ShakespeareSettings
r = QuasiQuoter { quoteExp :: [Char] -> Q Exp
quoteExp = ShakespeareSettings -> [Char] -> Q Exp
shakespeareFromString ShakespeareSettings
r }
shakespeareFromString :: ShakespeareSettings -> String -> Q Exp
shakespeareFromString :: ShakespeareSettings -> [Char] -> Q Exp
shakespeareFromString ShakespeareSettings
r [Char]
str = do
s <- 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
$ Maybe [Char] -> ShakespeareSettings -> [Char] -> IO [Char]
preFilter Maybe [Char]
forall a. Maybe a
Nothing ShakespeareSettings
r ([Char] -> IO [Char]) -> [Char] -> IO [Char]
forall a b. (a -> b) -> a -> b
$
#ifdef WINDOWS
filter (/='\r')
#endif
[Char]
str
contentsToShakespeare r $ contentFromString r s
shakespeareFile :: ShakespeareSettings -> FilePath -> Q Exp
shakespeareFile :: ShakespeareSettings -> [Char] -> Q Exp
shakespeareFile ShakespeareSettings
r [Char]
fp = [Char] -> Q [Char]
readFileRecompileQ [Char]
fp Q [Char] -> ([Char] -> Q Exp) -> Q Exp
forall a b. Q a -> (a -> Q b) -> Q b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ShakespeareSettings -> [Char] -> Q Exp
shakespeareFromString ShakespeareSettings
r
data VarType = VTPlain | VTUrl | VTUrlParam | VTMixin
deriving (Int -> VarType -> ShowS
[VarType] -> ShowS
VarType -> [Char]
(Int -> VarType -> ShowS)
-> (VarType -> [Char]) -> ([VarType] -> ShowS) -> Show VarType
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VarType -> ShowS
showsPrec :: Int -> VarType -> ShowS
$cshow :: VarType -> [Char]
show :: VarType -> [Char]
$cshowList :: [VarType] -> ShowS
showList :: [VarType] -> ShowS
Show, VarType -> VarType -> Bool
(VarType -> VarType -> Bool)
-> (VarType -> VarType -> Bool) -> Eq VarType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VarType -> VarType -> Bool
== :: VarType -> VarType -> Bool
$c/= :: VarType -> VarType -> Bool
/= :: VarType -> VarType -> Bool
Eq, Eq VarType
Eq VarType =>
(VarType -> VarType -> Ordering)
-> (VarType -> VarType -> Bool)
-> (VarType -> VarType -> Bool)
-> (VarType -> VarType -> Bool)
-> (VarType -> VarType -> Bool)
-> (VarType -> VarType -> VarType)
-> (VarType -> VarType -> VarType)
-> Ord VarType
VarType -> VarType -> Bool
VarType -> VarType -> Ordering
VarType -> VarType -> VarType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VarType -> VarType -> Ordering
compare :: VarType -> VarType -> Ordering
$c< :: VarType -> VarType -> Bool
< :: VarType -> VarType -> Bool
$c<= :: VarType -> VarType -> Bool
<= :: VarType -> VarType -> Bool
$c> :: VarType -> VarType -> Bool
> :: VarType -> VarType -> Bool
$c>= :: VarType -> VarType -> Bool
>= :: VarType -> VarType -> Bool
$cmax :: VarType -> VarType -> VarType
max :: VarType -> VarType -> VarType
$cmin :: VarType -> VarType -> VarType
min :: VarType -> VarType -> VarType
Ord, Int -> VarType
VarType -> Int
VarType -> [VarType]
VarType -> VarType
VarType -> VarType -> [VarType]
VarType -> VarType -> VarType -> [VarType]
(VarType -> VarType)
-> (VarType -> VarType)
-> (Int -> VarType)
-> (VarType -> Int)
-> (VarType -> [VarType])
-> (VarType -> VarType -> [VarType])
-> (VarType -> VarType -> [VarType])
-> (VarType -> VarType -> VarType -> [VarType])
-> Enum VarType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: VarType -> VarType
succ :: VarType -> VarType
$cpred :: VarType -> VarType
pred :: VarType -> VarType
$ctoEnum :: Int -> VarType
toEnum :: Int -> VarType
$cfromEnum :: VarType -> Int
fromEnum :: VarType -> Int
$cenumFrom :: VarType -> [VarType]
enumFrom :: VarType -> [VarType]
$cenumFromThen :: VarType -> VarType -> [VarType]
enumFromThen :: VarType -> VarType -> [VarType]
$cenumFromTo :: VarType -> VarType -> [VarType]
enumFromTo :: VarType -> VarType -> [VarType]
$cenumFromThenTo :: VarType -> VarType -> VarType -> [VarType]
enumFromThenTo :: VarType -> VarType -> VarType -> [VarType]
Enum, VarType
VarType -> VarType -> Bounded VarType
forall a. a -> a -> Bounded a
$cminBound :: VarType
minBound :: VarType
$cmaxBound :: VarType
maxBound :: VarType
Bounded, Typeable, Typeable VarType
Typeable VarType =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarType -> c VarType)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarType)
-> (VarType -> Constr)
-> (VarType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarType))
-> ((forall b. Data b => b -> b) -> VarType -> VarType)
-> (forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarType -> r)
-> (forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarType -> r)
-> (forall u. (forall d. Data d => d -> u) -> VarType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> VarType -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarType -> m VarType)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarType -> m VarType)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarType -> m VarType)
-> Data VarType
VarType -> Constr
VarType -> DataType
(forall b. Data b => b -> b) -> VarType -> VarType
forall a.
Typeable a =>
(forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> VarType -> u
forall u. (forall d. Data d => d -> u) -> VarType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarType -> m VarType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarType -> m VarType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarType -> c VarType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarType -> c VarType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarType -> c VarType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarType
$ctoConstr :: VarType -> Constr
toConstr :: VarType -> Constr
$cdataTypeOf :: VarType -> DataType
dataTypeOf :: VarType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarType)
$cgmapT :: (forall b. Data b => b -> b) -> VarType -> VarType
gmapT :: (forall b. Data b => b -> b) -> VarType -> VarType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VarType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> VarType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarType -> m VarType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarType -> m VarType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarType -> m VarType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarType -> m VarType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarType -> m VarType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarType -> m VarType
Data, (forall x. VarType -> Rep VarType x)
-> (forall x. Rep VarType x -> VarType) -> Generic VarType
forall x. Rep VarType x -> VarType
forall x. VarType -> Rep VarType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. VarType -> Rep VarType x
from :: forall x. VarType -> Rep VarType x
$cto :: forall x. Rep VarType x -> VarType
to :: forall x. Rep VarType x -> VarType
Generic)
getVars :: Content -> [(Deref, VarType)]
getVars :: Content -> [(Deref, VarType)]
getVars ContentRaw{} = []
getVars (ContentVar Deref
d) = [(Deref
d, VarType
VTPlain)]
getVars (ContentUrl Deref
d) = [(Deref
d, VarType
VTUrl)]
getVars (ContentUrlParam Deref
d) = [(Deref
d, VarType
VTUrlParam)]
getVars (ContentMix Deref
d) = [(Deref
d, VarType
VTMixin)]
data VarExp url = EPlain Builder
| EUrl url
| EUrlParam (url, QueryParameters)
| EMixin (Shakespeare url)
shakespeareUsedIdentifiers :: ShakespeareSettings -> String -> [(Deref, VarType)]
shakespeareUsedIdentifiers :: ShakespeareSettings -> [Char] -> [(Deref, VarType)]
shakespeareUsedIdentifiers ShakespeareSettings
settings = (Content -> [(Deref, VarType)]) -> [Content] -> [(Deref, VarType)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Content -> [(Deref, VarType)]
getVars ([Content] -> [(Deref, VarType)])
-> ([Char] -> [Content]) -> [Char] -> [(Deref, VarType)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShakespeareSettings -> [Char] -> [Content]
contentFromString ShakespeareSettings
settings
type MTime = UTCTime
{-# NOINLINE reloadMapRef #-}
reloadMapRef :: IORef (M.Map FilePath (MTime, [Content]))
reloadMapRef :: IORef (Map [Char] (MTime, [Content]))
reloadMapRef = IO (IORef (Map [Char] (MTime, [Content])))
-> IORef (Map [Char] (MTime, [Content]))
forall a. IO a -> a
unsafePerformIO (IO (IORef (Map [Char] (MTime, [Content])))
-> IORef (Map [Char] (MTime, [Content])))
-> IO (IORef (Map [Char] (MTime, [Content])))
-> IORef (Map [Char] (MTime, [Content]))
forall a b. (a -> b) -> a -> b
$ Map [Char] (MTime, [Content])
-> IO (IORef (Map [Char] (MTime, [Content])))
forall a. a -> IO (IORef a)
newIORef Map [Char] (MTime, [Content])
forall k a. Map k a
M.empty
lookupReloadMap :: FilePath -> IO (Maybe (MTime, [Content]))
lookupReloadMap :: [Char] -> IO (Maybe (MTime, [Content]))
lookupReloadMap [Char]
fp = do
reloads <- IORef (Map [Char] (MTime, [Content]))
-> IO (Map [Char] (MTime, [Content]))
forall a. IORef a -> IO a
readIORef IORef (Map [Char] (MTime, [Content]))
reloadMapRef
return $ M.lookup fp reloads
insertReloadMap :: FilePath -> (MTime, [Content]) -> IO [Content]
insertReloadMap :: [Char] -> (MTime, [Content]) -> IO [Content]
insertReloadMap [Char]
fp (MTime
mt, [Content]
content) = IORef (Map [Char] (MTime, [Content]))
-> (Map [Char] (MTime, [Content])
-> (Map [Char] (MTime, [Content]), [Content]))
-> IO [Content]
forall a b. IORef a -> (a -> (a, b)) -> IO b
atomicModifyIORef IORef (Map [Char] (MTime, [Content]))
reloadMapRef
(\Map [Char] (MTime, [Content])
reloadMap -> ([Char]
-> (MTime, [Content])
-> Map [Char] (MTime, [Content])
-> Map [Char] (MTime, [Content])
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert [Char]
fp (MTime
mt, [Content]
content) Map [Char] (MTime, [Content])
reloadMap, [Content]
content))
shakespeareFileReload :: ShakespeareSettings -> FilePath -> Q Exp
shakespeareFileReload :: ShakespeareSettings -> [Char] -> Q Exp
shakespeareFileReload ShakespeareSettings
settings [Char]
fp = do
str <- [Char] -> Q [Char]
readFileQ [Char]
fp
s <- qRunIO $ preFilter (Just fp) settings str
let b = ShakespeareSettings -> [Char] -> [(Deref, VarType)]
shakespeareUsedIdentifiers ShakespeareSettings
settings [Char]
s
c <- mapM vtToExp b
rt <- [|shakespeareRuntime settings fp|]
wrap' <- [|\x -> $(return $ wrap settings) . x|]
return $ wrap' `AppE` (rt `AppE` ListE c)
where
vtToExp :: (Deref, VarType) -> Q Exp
vtToExp :: (Deref, VarType) -> Q Exp
vtToExp (Deref
d, VarType
vt) = do
d' <- Deref -> Q Exp
forall t (m :: * -> *). (Lift t, Quote m) => t -> m Exp
forall (m :: * -> *). Quote m => Deref -> m Exp
lift Deref
d
c' <- c vt
return $ TupE
#if MIN_VERSION_template_haskell(2,16,0)
$ map Just
#endif
[d', c' `AppE` derefToExp [] d]
where
c :: VarType -> Q Exp
c :: VarType -> Q Exp
c VarType
VTPlain = [|EPlain . $(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
$
Maybe Exp -> Exp -> Maybe Exp -> Exp
InfixE (Exp -> Maybe Exp
forall a. a -> Maybe a
Just (Exp -> Maybe Exp) -> Exp -> Maybe Exp
forall a b. (a -> b) -> a -> b
$ ShakespeareSettings -> Exp
unwrap ShakespeareSettings
settings) (Name -> Exp
VarE '(.)) (Exp -> Maybe Exp
forall a. a -> Maybe a
Just (Exp -> Maybe Exp) -> Exp -> Maybe Exp
forall a b. (a -> b) -> a -> b
$ ShakespeareSettings -> Exp
toBuilder ShakespeareSettings
settings))|]
c VarType
VTUrl = [|EUrl|]
c VarType
VTUrlParam = [|EUrlParam|]
c VarType
VTMixin = [|\x -> EMixin $ \r -> $(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
$ ShakespeareSettings -> Exp
unwrap ShakespeareSettings
settings) $ x r|]
nothingError :: Show a => String -> a -> b
nothingError :: forall a b. Show a => [Char] -> a -> b
nothingError [Char]
expected a
d = [Char] -> b
forall a. HasCallStack => [Char] -> a
error ([Char] -> b) -> [Char] -> b
forall a b. (a -> b) -> a -> b
$ [Char]
"expected " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
expected [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" but got Nothing for: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ a -> [Char]
forall a. Show a => a -> [Char]
show a
d
shakespeareRuntime :: ShakespeareSettings -> FilePath -> [(Deref, VarExp url)] -> Shakespeare url
shakespeareRuntime :: forall url.
ShakespeareSettings
-> [Char] -> [(Deref, VarExp url)] -> Shakespeare url
shakespeareRuntime ShakespeareSettings
settings [Char]
fp [(Deref, VarExp url)]
cd RenderUrl url
render' = IO Builder -> Builder
forall a. IO a -> a
unsafePerformIO (IO Builder -> Builder) -> IO Builder -> Builder
forall a b. (a -> b) -> a -> b
$ do
mtime <- IO MTime -> IO MTime
forall a. IO a -> IO a
forall (m :: * -> *) a. Quasi m => IO a -> m a
qRunIO (IO MTime -> IO MTime) -> IO MTime -> IO MTime
forall a b. (a -> b) -> a -> b
$ [Char] -> IO MTime
getModificationTime [Char]
fp
mdata <- lookupReloadMap fp
case mdata of
Just (MTime
lastMtime, [Content]
lastContents) ->
if MTime
mtime MTime -> MTime -> Bool
forall a. Eq a => a -> a -> Bool
== MTime
lastMtime then Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Builder -> IO Builder) -> Builder -> IO Builder
forall a b. (a -> b) -> a -> b
$ [Content] -> Builder
go' [Content]
lastContents
else ([Content] -> Builder) -> IO [Content] -> IO Builder
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Content] -> Builder
go' (IO [Content] -> IO Builder) -> IO [Content] -> IO Builder
forall a b. (a -> b) -> a -> b
$ MTime -> IO [Content]
newContent MTime
mtime
Maybe (MTime, [Content])
Nothing -> ([Content] -> Builder) -> IO [Content] -> IO Builder
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Content] -> Builder
go' (IO [Content] -> IO Builder) -> IO [Content] -> IO Builder
forall a b. (a -> b) -> a -> b
$ MTime -> IO [Content]
newContent MTime
mtime
where
newContent :: MTime -> IO [Content]
newContent MTime
mtime = do
str <- [Char] -> IO [Char]
readUtf8FileString [Char]
fp
s <- preFilter (Just fp) settings str
insertReloadMap fp (mtime, contentFromString settings s)
go' :: [Content] -> Builder
go' = [Builder] -> Builder
forall a. Monoid a => [a] -> a
mconcat ([Builder] -> Builder)
-> ([Content] -> [Builder]) -> [Content] -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Content -> Builder) -> [Content] -> [Builder]
forall a b. (a -> b) -> [a] -> [b]
map Content -> Builder
go
go :: Content -> Builder
go :: Content -> Builder
go (ContentRaw [Char]
s) = Text -> Builder
fromText (Text -> Builder) -> Text -> Builder
forall a b. (a -> b) -> a -> b
$ [Char] -> Text
TS.pack [Char]
s
go (ContentVar Deref
d) =
case Deref -> [(Deref, VarExp url)] -> Maybe (VarExp url)
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Deref
d [(Deref, VarExp url)]
cd of
Just (EPlain Builder
s) -> Builder
s
Maybe (VarExp url)
_ -> [Char] -> Deref -> Builder
forall a b. Show a => [Char] -> a -> b
nothingError [Char]
"EPlain" Deref
d
go (ContentUrl Deref
d) =
case Deref -> [(Deref, VarExp url)] -> Maybe (VarExp url)
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Deref
d [(Deref, VarExp url)]
cd of
Just (EUrl url
u) -> Text -> Builder
fromText (Text -> Builder) -> Text -> Builder
forall a b. (a -> b) -> a -> b
$ RenderUrl url
render' url
u []
Maybe (VarExp url)
_ -> [Char] -> Deref -> Builder
forall a b. Show a => [Char] -> a -> b
nothingError [Char]
"EUrl" Deref
d
go (ContentUrlParam Deref
d) =
case Deref -> [(Deref, VarExp url)] -> Maybe (VarExp url)
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Deref
d [(Deref, VarExp url)]
cd of
Just (EUrlParam (url
u, [(Text, Text)]
p)) ->
Text -> Builder
fromText (Text -> Builder) -> Text -> Builder
forall a b. (a -> b) -> a -> b
$ RenderUrl url
render' url
u [(Text, Text)]
p
Maybe (VarExp url)
_ -> [Char] -> Deref -> Builder
forall a b. Show a => [Char] -> a -> b
nothingError [Char]
"EUrlParam" Deref
d
go (ContentMix Deref
d) =
case Deref -> [(Deref, VarExp url)] -> Maybe (VarExp url)
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Deref
d [(Deref, VarExp url)]
cd of
Just (EMixin Shakespeare url
m) -> Shakespeare url
m RenderUrl url
render'
Maybe (VarExp url)
_ -> [Char] -> Deref -> Builder
forall a b. Show a => [Char] -> a -> b
nothingError [Char]
"EMixin" Deref
d