{-# 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 #-}
-- | NOTE: This module should be considered internal, and will be hidden in
-- future releases.
module Text.Shakespeare
    ( ShakespeareSettings (..)
    , PreConvert (..)
    , WrapInsertion (..)
    , PreConversion (..)
    , defaultShakespeareSettings
    , shakespeare
    , shakespeareFile
    , shakespeareFileReload
    -- * low-level
    , shakespeareFromString
    , shakespeareUsedIdentifiers
    , RenderUrl
    , VarType (..)
    , Deref
    , Parser

    , preFilter
      -- * Internal
      -- can we remove this?
    , 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 orphan Lift Name instance
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)

-- for pre conversion
import System.Process (readProcessWithExitCode)
import System.Exit (ExitCode(..))

-- | A parser with a user state of [String]
type Parser = Parsec String [String]
-- | run a parser with a user state of [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 []

-- | Coffeescript, TypeScript, and other languages compiles down to Javascript.
-- Previously we waited until the very end, at the rendering stage to perform this compilation.
-- Lets call is a post-conversion
-- This had the advantage that all Haskell values were inserted first:
-- for example a value could be inserted that Coffeescript would compile into Javascript.
-- While that is perhaps a safer approach, the advantage is not used in practice:
-- it was that way mainly for ease of implementation.
-- The down-side is the template must be compiled down to Javascript during every request.
-- If instead we do a pre-conversion to compile down to Javascript,
-- we only need to perform the compilation once.
--
-- The problem then is the insertion of Haskell values: we need a hole for
-- them. This can be done with variables known to the language.
-- During the pre-conversion we first modify all Haskell insertions
-- So #{a} is change to shakespeare_var_a
-- Then we can place the Haskell values in a function wrapper that exposes
-- those variables: (function(shakespeare_var_a){ ... shakespeare_var_a ...})
-- TypeScript can compile that, and then we tack an application of the
-- Haskell values onto the result: (#{a})
--
-- preEscapeIgnoreBalanced is used to not insert backtacks for variable already inside strings or backticks.
-- coffeescript will happily ignore the interpolations, and backticks would not be treated as escaping in that context.
-- preEscapeIgnoreLine was added to ignore comments (which in Coffeescript begin with a '#')

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
    -- ^ A transformation applied to the final expression. Most often, this
    -- would be used to force the type of the expression to help make more
    -- meaningful error messages.
    }

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])


-- | calls 'error' when there is stderr or exit code failure
readProcessError :: FilePath -> [String] -> String
                 -> Maybe FilePath -- ^ for error reporting
                 -> 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 -- ^ for error reporting
          -> 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
        -- Make sure we convert this mempty using toBuilder to pin down the
        -- type appropriately
        []  -> (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)

-- | Determine which identifiers are used by the given template, useful for
-- creating systems like yesod devel.
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