@@ -1,93 +1,93 @@
1−{-# LANGUAGE TemplateHaskell, OverloadedStrings #-}
1+{-# LANGUAGE TemplateHaskell #-}
2+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
3+{-# LANGUAGE FlexibleInstances #-}
4+{-# LANGUAGE CPP #-}
25{-# OPTIONS_GHC -fno-warn-missing-fields #-}
36
4−module Language.Elm.Quasi (elm, elmFile) where
5−
6−import Language.Haskell.TH.Quote
7−import Language.Haskell.TH
8−import Language.Haskell.Meta (parseExp)
9−
10−import Data.Attoparsec.Text
11−import Data.Text as T (Text, pack, unpack, strip)
12−
13−{- | This QuasiQuoter allows for literal embedding of elm source code within
14− Haskell files. It is not responsible for the actual compilation Process.
15− Usage:
16−
17− @
18− elmPage = [elm|
19− main = image \"someImage.jpg\"
20− |]
21− @
22−
23− It also allows for simple variable interpolation using the ^{...} syntax.
24− This is intended for e.g. embedding pre-rendered type-safe URLs.
25− All interpolated variables must be a member of the Show typeclass. This
26− is not tested with more complicated expressions, so it is recommended to
27− restrict usage of interpolation to pre-calculated variables.
28−
29− Example:
30−
31− > let google = "http://google.com"
32− > in [elm|
33− > main = text $ link ^{google} (toText "Google")
34− > |]
35−
36−
37− How the elm code is compiled depends on how you intend to use it.
38− Example uses are the included 'generateHtml' function as well as the
39− "Language.Elm.Yesod" module.
40−-}
41−elm :: QuasiQuoter
42−elm = QuasiQuoter
43− { quoteExp = \s ->
44− let chunks = flip map (getQChunks s) $ \c ->
45− case c of
46− S t -> [| t |]
47− E t -> let Right e = parseExp t in appE [| show |] (return e)
48− in appE [| concat |] (listE chunks)
7+-- | This module contains Shakespearean (see "Text.Shakespeare") templates for Elm.
8+-- It introduces type-safe compile-time variable and URL interpolation. A typeclass
9+-- @'ToElm'@ is provided for interpolated variables.
10+--
11+-- Further reading on Shakespearean templates: <http://www.yesodweb.com/book/templates>
12+--
13+-- Further reading on Elm: <http://elm-lang.org>
14+module Language.Elm.Quasi
15+ ( -- * Functions
16+ -- ** Template-Reading Functions
17+ -- |These QuasiQuoters return functions of the type @(t -> 'Elm')@
18+ -- where @t@ is the URL rendering function if type-safe URLs are used.
19+ --
20+ -- A usage example for both type-safe (Yesod) and standard path segment (Happstack)
21+ -- URLs is provided in the Examples folder in the Git repository.
22+ elm
23+ , elmFile
24+ , elmFileReload
25+
26+ -- * Datatypes
27+ , Elm (..)
28+
29+ -- * Typeclass for interpolated variables
30+ , ToElm (..)
31+
32+ -- ** Rendering Functions
33+ , renderElm
34+
35+ ) where
36+
37+import Language.Haskell.TH.Quote (QuasiQuoter (..))
38+import Language.Haskell.TH.Syntax
39+import Data.Text.Lazy.Builder (Builder, fromText, toLazyText, fromLazyText)
40+import Data.Monoid
41+import qualified Data.Text as TS
42+import qualified Data.Text.Lazy as TL
43+import Text.Shakespeare
44+
45+-- | Render Elm to lazy Text.
46+renderElm :: Elm -> TL.Text
47+renderElm (Elm b) = toLazyText b
48+
49+-- | Newtype wrapper of 'Builder'.
50+newtype Elm = Elm { unElm :: Builder }
51+ deriving Monoid
52+
53+-- | A typeclass for types that can be interpolated in Elm templates.
54+class ToElm a where
55+ toElm :: a -> Builder
56+instance ToElm [Char] where toElm = fromLazyText . TL.pack
57+instance ToElm TS.Text where toElm = fromText
58+instance ToElm TL.Text where toElm = fromLazyText
59+
60+elmSettings :: Q ShakespeareSettings
61+elmSettings = do
62+ toJExp <- [|toElm|]
63+ wrapExp <- [|Elm|]
64+ unWrapExp <- [|unElm|]
65+ return $ defaultShakespeareSettings { toBuilder = toJExp
66+ , wrap = wrapExp
67+ , unwrap = unWrapExp
4968 }
5069
51−{- | elmFile is a quoteFile wrapper around the 'elm' QuasiQuoter and allows for
52− external elm source files to be embedded.
53− Usage:
54−
55− @
56− [elmFile|elm-source/page.elm|]
57− @
58−
59− Please note that no spaces should be added before and after the filename.
60−-}
61−elmFile :: QuasiQuoter
62−elmFile = quoteFile elm
63−
64−data QChunk =
65− S String -- ^ A literal string
66− | E String -- ^ An expression (must be of the Show typeclass)
67− deriving (Show, Eq)
68−
69−
70−{- thanks to mikeplus64 for providing an example QuasiQuoter that I could look at while writing this :) -}
71−getQChunks :: String -> [QChunk]
72−getQChunks si = let i = T.pack si
73− Right m = parseOnly parser (strip i) in m
74− where
75− parser = go []
76−
77− go s = do
78− txt <- takeTill (== '^')
79− evt <- choice [expression, fmap (S . T.unpack) takeText]
80− end <- atEnd
81− if end
82− then return $ filter (not . blank) $ reverse (evt:(S . T.unpack) txt:s)
83− else go (evt:(S . T.unpack) txt:s)
84−
85− blank (S "") = True
86− blank (E "") = True
87− blank _ = False
88−
89− expression = do
90− string "^{"
91− expr <- takeTill (== '}')
92− char '}'
93− return $ (E . T.unpack) expr
70+-- |QuasiQuoter for embedding Elm code inside of Haskell code.
71+--
72+-- Usage:
73+-- @[elm|main = plaintext "Some elm code"|]@
74+elm :: QuasiQuoter
75+elm = QuasiQuoter { quoteExp = \s -> do
76+ rs <- elmSettings
77+ quoteExp (shakespeare rs) s
78+ }
79+
80+-- |A Template Haskell function for embedding Elm code from external
81+-- .elm files.
82+--
83+-- Usage:
84+-- @$(elmFile "elm_source/index.elm")@
85+elmFile :: FilePath -> Q Exp
86+elmFile fp = do
87+ rs <- elmSettings
88+ shakespeareFile rs fp
89+
90+elmFileReload :: FilePath -> Q Exp
91+elmFileReload fp = do
92+ rs <- elmSettings
93+ shakespeareFileReload rs fp