{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE CPP #-}
{-# OPTIONS_GHC -fno-warn-missing-fields #-}
-- | A Shakespearean module for Roy, introducing type-safe,
-- compile-time variable and url interpolation. It is exactly the same as
-- "Text.Julius", except that the template is first compiled to Javascript with
-- the system tool @roy@.
--
-- To use this module, @roy@ must be installed on your system.
--
-- If you interpolate variables,
-- the template is first wrapped with a function containing javascript variables representing shakespeare variables,
-- then compiled with @roy@,
-- and then the value of the variables are applied to the function.
-- This means that in production the template can be compiled
-- once at compile time and there will be no dependency in your production
-- system on @roy@. 
--
-- Your code:
--
-- > let b = 1
-- > console.log(#{a} + b)
--
-- Final Result:
--
-- > ;(function(shakespeare_var_a){
-- >   var b = 1;
-- >   console.log(shakespeare_var_a + b);
-- > })(#{a});
--
-- Further reading:
--
-- 1. Shakespearean templates: <https://www.yesodweb.com/book/shakespearean-templates>
--
-- 2. Roy: <http://roy.brianmckenna.org/>
module Text.Roy
    ( -- * Functions
      -- ** Template-Reading Functions
      -- | These QuasiQuoter and Template Haskell methods return values of
      -- type @'JavascriptUrl' url@. See the Yesod book for details.
      roy
    , royFile
    , royFileReload

#ifdef TEST_EXPORT
    , roySettings
#endif
    ) where

import Language.Haskell.TH.Quote (QuasiQuoter (..))
import Language.Haskell.TH.Syntax
import Text.Shakespeare
import Text.Julius

-- | The Roy language compiles down to Javascript.
-- We do this compilation once at compile time to avoid needing to do it during the request.
-- We call this a preConversion because other shakespeare modules like Lucius use Haskell to compile during the request instead rather than a system call.
roySettings :: Q ShakespeareSettings
roySettings :: Q ShakespeareSettings
roySettings = do
  ShakespeareSettings
jsettings <- Q ShakespeareSettings
javascriptSettings
  ShakespeareSettings -> Q ShakespeareSettings
forall (m :: * -> *) a. Monad m => a -> m a
return (ShakespeareSettings -> Q ShakespeareSettings)
-> ShakespeareSettings -> Q ShakespeareSettings
forall a b. (a -> b) -> a -> b
$ ShakespeareSettings
jsettings { varChar :: Char
varChar = '#'
  , preConversion :: Maybe PreConvert
preConversion = PreConvert -> Maybe PreConvert
forall a. a -> Maybe a
Just PreConvert :: PreConversion
-> [Char] -> [Char] -> Maybe WrapInsertion -> PreConvert
PreConvert {
      preConvert :: PreConversion
preConvert = [Char] -> [[Char]] -> PreConversion
ReadProcess "roy" ["--stdio", "--browser"]
    , preEscapeIgnoreBalanced :: [Char]
preEscapeIgnoreBalanced = "'\""
    , preEscapeIgnoreLine :: [Char]
preEscapeIgnoreLine = "//"
    , wrapInsertion :: Maybe WrapInsertion
wrapInsertion = WrapInsertion -> Maybe WrapInsertion
forall a. a -> Maybe a
Just WrapInsertion :: Maybe [Char]
-> [Char] -> [Char] -> [Char] -> [Char] -> Bool -> WrapInsertion
WrapInsertion {
        wrapInsertionIndent :: Maybe [Char]
wrapInsertionIndent = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just "  "
      , wrapInsertionStartBegin :: [Char]
wrapInsertionStartBegin = "(\\"
      , wrapInsertionSeparator :: [Char]
wrapInsertionSeparator = " "
      , wrapInsertionStartClose :: [Char]
wrapInsertionStartClose = " ->\n"
      , wrapInsertionEnd :: [Char]
wrapInsertionEnd = ")"
      , wrapInsertionAddParens :: Bool
wrapInsertionAddParens = Bool
True
      }
    }
  }

-- | Read inline, quasiquoted Roy.
roy :: QuasiQuoter
roy :: QuasiQuoter
roy = QuasiQuoter :: ([Char] -> Q Exp)
-> ([Char] -> Q Pat)
-> ([Char] -> Q Type)
-> ([Char] -> Q [Dec])
-> QuasiQuoter
QuasiQuoter { quoteExp :: [Char] -> Q Exp
quoteExp = \s :: [Char]
s -> do
    ShakespeareSettings
rs <- Q ShakespeareSettings
roySettings
    QuasiQuoter -> [Char] -> Q Exp
quoteExp (ShakespeareSettings -> QuasiQuoter
shakespeare ShakespeareSettings
rs) [Char]
s
    }

-- | Read in a Roy template file. This function reads the file once, at
-- compile time.
royFile :: FilePath -> Q Exp
royFile :: [Char] -> Q Exp
royFile fp :: [Char]
fp = do
    ShakespeareSettings
rs <- Q ShakespeareSettings
roySettings
    ShakespeareSettings -> [Char] -> Q Exp
shakespeareFile ShakespeareSettings
rs [Char]
fp

-- | Read in a Roy template file. This impure function uses
-- unsafePerformIO to re-read the file on every call, allowing for rapid
-- iteration.
royFileReload :: FilePath -> Q Exp
royFileReload :: [Char] -> Q Exp
royFileReload fp :: [Char]
fp = do
    ShakespeareSettings
rs <- Q ShakespeareSettings
roySettings
    ShakespeareSettings -> [Char] -> Q Exp
shakespeareFileReload ShakespeareSettings
rs [Char]
fp