shakespeare-2.0.11.1/0000755000000000000000000000000012762212723012417 5ustar0000000000000000shakespeare-2.0.11.1/ChangeLog.md0000644000000000000000000000647212762212723014601 0ustar0000000000000000### 2.0.11.1 * Handle parsing of trailing semicolon after mixins [#194](https://github.com/yesodweb/shakespeare/issues/194) ### 2.0.11 * Export hamletFromString [#191](https://github.com/yesodweb/shakespeare/pull/191) ### 2.0.10 * Added `ixhamlet` [#177](https://github.com/yesodweb/shakespeare/pull/177) ### 2.0.9 * Better empty HTML tag list ### 2.0.8.1 * Make it work with ghc-8.0 [#181](https://github.com/yesodweb/shakespeare/pull/181) ### 2.0.8 * Improve docs in Text.Hamlet [#180](https://github.com/yesodweb/shakespeare/pull/180) ### 2.0.7 * Include aeson's JSON encoding and escape `<`, `>` and `&` to avoid XSS attacks ### 2.0.6 * Provide the `Text.Hamlet.Runtime` module ### 2.0.5 * Drop system-filepath ### 2.0.4.1 Fix build for GHC 7.10 [#151](https://github.com/yesodweb/shakespeare/pull/151) ### 2.0.4 * [Add multiline literal aligned with bar #148](https://github.com/yesodweb/shakespeare/pull/148) ### 2.0.3 * `cassiusMixin` added ### 2.0.2.2 GHC 7.10 support ### shakesepare 2.0.2 shakespeare-i18n supports message directories. ### Hamlet 0.5.0 (August 29, 2010) * Use can use parantheses when referencing variables. This allows you to have functions applied to multiple arguments. * Added the hamlet' and xhamlet' quasiquoters for generating plain Html values. * Added runtime Hamlet support. * Added "file debug" support. This is a mode that is a drop-in replacement for external files compiled via template haskell. However, this mode also has a runtime component, in that is reads your templates at runtime, thus avoiding the need to a recompile for each template change. This takes a runtime hit obviously, so it's recommended that you switch back to the compile-time templates for production systems. * Added the Cassius and Julius template languages for CSS and Javascript, respectively. The former is white-space sensitive, whereas the latter is just a passthrough for raw Javascript code. The big feature in both of them is that they support variable interpolation just like Hamlet does. ### New in Hamlet 0.4.0 * Internal template parsing is now done via Parsec. This opened the doors for the other changes mentioned below, but also hopefully gives more meaningful error messages. There's absolutely no runtime performance hit for this change, since all parsing is done at compile time, and if there *is* any compile-time hit, it's too negligible to be noticed. * Attribute values can now be quoted. This allows you to embed spaces, periods and pounds in an attribute value. For example: [$hamlet|%input!type=submit!value="Add new value"|]. * Space-delimited references in addition to period-delimited ones. This only applies to references in content, not in statements. For example, you could write [\$hamlet|\$foo bar baz\$|]. * Dollar-sign interpolation is now polymorphic, based on the ToHtml typeclass. You can now do away with \$string.var\$ and simply type \$var\$. Currently, the ToHtml typeclass is not exposed, and it only provides instances for String and Html, though this is open for discussion. * Added hamletFile and xhamletFile which loads a Hamlet template from an external file. The file is parsed at compile time, just like a quasi-quoted template, and must be UTF-8 encoded. Additionally, be warned that the compiler won't automatically know to recompile a module if the template file gets changed. shakespeare-2.0.11.1/LICENSE0000644000000000000000000000207512762212723013430 0ustar0000000000000000Copyright (c) 2012 Michael Snoyman, http://www.yesodweb.com/ Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. shakespeare-2.0.11.1/Setup.lhs0000644000000000000000000000021712762212723014227 0ustar0000000000000000#!/usr/bin/env runhaskell > module Main where > import Distribution.Simple > import System.Cmd (system) > main :: IO () > main = defaultMain shakespeare-2.0.11.1/shakespeare.cabal0000644000000000000000000001126612762212723015704 0ustar0000000000000000name: shakespeare version: 2.0.11.1 license: MIT license-file: LICENSE author: Michael Snoyman maintainer: Michael Snoyman synopsis: A toolkit for making compile-time interpolated templates description: Shakespeare is a family of type-safe, efficient template languages. Shakespeare templates are expanded at compile-time, ensuring that all interpolated variables are in scope. Variables are interpolated according to their type through a typeclass. . Shakespeare templates can be used inline with a quasi-quoter or in an external file. . Note there is no dependency on haskell-src-extras. Instead Shakespeare believes logic should stay out of templates and has its own minimal Haskell parser. . Packages that use this: xml-hamlet . Please see the documentation at for more details. category: Web, Yesod stability: Stable cabal-version: >= 1.8 build-type: Simple homepage: http://www.yesodweb.com/book/shakespearean-templates extra-source-files: test/reload.txt test/texts/*.text test/juliuses/*.julius test/juliuses/*.coffee test-messages/*.msg test/cassiuses/*.cassius test/cassiuses/*.lucius test/hamlets/*.hamlet test/tmp.hs ChangeLog.md library build-depends: base >= 4 && < 5 , time >= 1 , containers , template-haskell >= 2.7 , parsec >= 2 && < 4 , text >= 0.7 , process >= 1.0 , ghc-prim , bytestring , directory >= 1.2 , aeson , blaze-markup , blaze-html , exceptions , transformers , vector , unordered-containers , scientific >= 0.3.0.0 exposed-modules: Text.Shakespeare.I18N Text.Shakespeare.Text Text.Roy Text.Julius Text.Coffee Text.Hamlet Text.Hamlet.RT Text.Hamlet.Runtime Text.Lucius Text.Cassius Text.Shakespeare.Base Text.Shakespeare Text.TypeScript other-modules: Text.Hamlet.Parse Text.Css Text.MkSizeType Text.IndentToBrace Text.CssCommon ghc-options: -Wall if flag(test_export) cpp-options: -DTEST_EXPORT extensions: TemplateHaskell if impl(ghc >= 7.4) cpp-options: -DGHC_7_4 if os(windows) CPP-Options: "-DWINDOWS" if flag(test_coffee) cpp-options: -DTEST_COFFEE if flag(test_roy) cpp-options: -DTEST_ROY if flag(test_export) cpp-options: -DTEST_EXPORT Flag test_export default: False flag test_coffee description: render tests through coffeescript render function -- cabal configure --enable-tests -ftest_coffee && cabal build && dist/build/test/test default: False flag test_roy description: render tests through coffeescript render function -- cabal configure --enable-tests -ftest_coffee && cabal build && dist/build/test/test default: False test-suite test hs-source-dirs: test main-is: Spec.hs other-modules: Text.Shakespeare.BaseSpec Text.Shakespeare.I18NSpec Text.Shakespeare.TextSpec Text.CssSpec Text.HamletSpec Text.JuliusSpec Quoter HamletTestTypes cpp-options: -DTEST_EXPORT type: exitcode-stdio-1.0 ghc-options: -Wall build-depends: base >= 4 && < 5 , shakespeare , time >= 1 , containers , parsec >= 2 && < 4 , hspec == 2.* , text >= 0.7 , process , template-haskell >= 2.7 , ghc-prim , HUnit , bytestring , directory , aeson , transformers , blaze-markup , blaze-html , exceptions extensions: TemplateHaskell source-repository head type: git location: https://github.com/yesodweb/shakespeare.git shakespeare-2.0.11.1/test/0000755000000000000000000000000012762212723013376 5ustar0000000000000000shakespeare-2.0.11.1/test/HamletTestTypes.hs0000644000000000000000000000036712762212723017037 0ustar0000000000000000module HamletTestTypes where -- This record is defined outside of the HamletTest module -- because record wildcards use 'reify' and reify doesn't -- see types defined in the local module. data ARecord = ARecord { field1 :: Int, field2 :: Bool } shakespeare-2.0.11.1/test/Quoter.hs0000644000000000000000000000174412762212723015217 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# OPTIONS_GHC -fno-warn-missing-fields #-} module Quoter (quote, quoteFile, quoteFileReload) where import Language.Haskell.TH.Syntax import Language.Haskell.TH.Quote (QuasiQuoter (..)) #ifdef TEST_COFFEE import Text.Coffee import Text.Coffee (coffeeSettings) import Text.Shakespeare (shakespeare) #else # ifdef TEST_ROY import Text.Roy # else import Text.Julius # endif #endif quote :: QuasiQuoter quoteFile :: FilePath -> Q Exp quoteFileReload :: FilePath -> Q Exp #ifdef TEST_COFFEE translate ('#':'{':rest) = translate $ '%':'{':translate rest translate (c:other) = c:translate other translate [] = [] quote = QuasiQuoter { quoteExp = \s -> do rs <- coffeeSettings quoteExp (shakespeare rs) (translate s) } quoteFile = coffeeFile quoteFileReload = coffeeFileReload #else # ifdef TEST_ROY quote = roy quoteFile = royFile quoteFileReload = royFileReload # else quote = julius quoteFile = juliusFile quoteFileReload = juliusFileReload # endif #endif shakespeare-2.0.11.1/test/reload.txt0000644000000000000000000000001112762212723015375 0ustar0000000000000000#{input} shakespeare-2.0.11.1/test/Spec.hs0000644000000000000000000000005412762212723014623 0ustar0000000000000000{-# OPTIONS_GHC -F -pgmF hspec-discover #-} shakespeare-2.0.11.1/test/tmp.hs0000644000000000000000000000101512762212723014527 0ustar0000000000000000data Url = Home | Img renderUrl' Home = "http://localhost/" renderUrl' Img = "http://localhost/image.png" data Obj = Obj { foo :: Url , bar :: IO String } main = myTemp renderUrl' $ Obj Img (return "some bar value") myTemp renderUrl obj = do putStr "Foo Bar Baz

Hello World

Bar Baz
Plain Content" bar obj >>= putStr putStr "
" shakespeare-2.0.11.1/test/cassiuses/0000755000000000000000000000000012762212723015400 5ustar0000000000000000shakespeare-2.0.11.1/test/cassiuses/external-media.lucius0000644000000000000000000000012412762212723021522 0ustar0000000000000000@media only screen{ foo { bar { baz: bin; } } } shakespeare-2.0.11.1/test/cassiuses/external-nested.lucius0000644000000000000000000000010412762212723021723 0ustar0000000000000000@topvarbin: bin; foo { bar { baz: #{topvarbin}; } } shakespeare-2.0.11.1/test/cassiuses/external1.cassius0000644000000000000000000000035712762212723020704 0ustar0000000000000000#{selector} background: #{colorBlack} bar: baz color: #{colorRed} bin background-image: url(@{Home}) bar: bar color: #{(((Color 127) 100) 5)} f#{var}x: someval unicode-test: שלום urlp: url(@?{urlp}) shakespeare-2.0.11.1/test/cassiuses/external1.lucius0000644000000000000000000000037012762212723020531 0ustar0000000000000000foo { background: #{colorBlack}; bar: baz; color: #{colorRed}; } bin { background-image: url(@{Home}); bar: bar; color: #{(((Color 127) 100) 5)}; f#{var}x: someval; unicode-test: שלום; urlp: url(@?{urlp}); } shakespeare-2.0.11.1/test/cassiuses/external2.cassius0000644000000000000000000000001712762212723020676 0ustar0000000000000000foo #{var}: 2shakespeare-2.0.11.1/test/cassiuses/external2.lucius0000644000000000000000000000001612762212723020527 0ustar0000000000000000foo{#{var}: 1}shakespeare-2.0.11.1/test/cassiuses/mixin.lucius0000644000000000000000000000002312762212723017745 0ustar0000000000000000selector{^{mixin}} shakespeare-2.0.11.1/test/cassiuses/reload-import.cassius0000644000000000000000000000002512762212723021547 0ustar0000000000000000@import url(@{Home}) shakespeare-2.0.11.1/test/hamlets/0000755000000000000000000000000012762212723015033 5ustar0000000000000000shakespeare-2.0.11.1/test/hamlets/double-foralls.hamlet0000644000000000000000000000005512762212723021141 0ustar0000000000000000$forall _ <- list $forall l <- list #{l} shakespeare-2.0.11.1/test/hamlets/embed.hamlet0000644000000000000000000000002012762212723017273 0ustar0000000000000000^{embed theArg} shakespeare-2.0.11.1/test/hamlets/external-debug.hamlet0000644000000000000000000000001012762212723021124 0ustar0000000000000000#{foo} 1shakespeare-2.0.11.1/test/hamlets/external-debug2.hamlet0000644000000000000000000000064212762212723021221 0ustar0000000000000000#{var} #{id var} @{url} @{Home} @{Sub SubUrl} @?{urlp} ^{template} $if id true true #{id $ id $ id (id $ id extra)} $if not true $else not true #{id $ id $ id (id extra)} $if not true $elseif true elseif true #{id $ id(id extra)} $maybe j <- just #{j} #{id j} #{id (id extra)} $maybe _ <- nothing $nothing nothing #{id extra} $forall l <- list #{id $ id l} #{extra} shakespeare-2.0.11.1/test/hamlets/external-debug3.hamlet0000644000000000000000000000005612762212723021221 0ustar0000000000000000$forall list a $a$ $forall list b $b$ shakespeare-2.0.11.1/test/hamlets/external.hamlet0000644000000000000000000000001412762212723020044 0ustar0000000000000000#{foo}
shakespeare-2.0.11.1/test/hamlets/nonpolyhamlet.hamlet0000644000000000000000000000001412762212723021113 0ustar0000000000000000

@{Home} shakespeare-2.0.11.1/test/hamlets/nonpolyhtml.hamlet0000644000000000000000000000002012762212723020602 0ustar0000000000000000

HELLO WORLD shakespeare-2.0.11.1/test/hamlets/nonpolyihamlet.hamlet0000644000000000000000000000001512762212723021265 0ustar0000000000000000

_{Hello} shakespeare-2.0.11.1/test/juliuses/0000755000000000000000000000000012762212723015241 5ustar0000000000000000shakespeare-2.0.11.1/test/juliuses/external1.coffee0000644000000000000000000000006312762212723020314 0ustar0000000000000000'שלום' %{var} '@{Home}' '@?{urlp}' ^{cofmixin} shakespeare-2.0.11.1/test/juliuses/external1.julius0000644000000000000000000000006112762212723020376 0ustar0000000000000000שלום #{rawJS var} @{Home} @?{urlp} ^{jmixin} shakespeare-2.0.11.1/test/juliuses/external2.julius0000644000000000000000000000001712762212723020400 0ustar0000000000000000var #{var} = 2;shakespeare-2.0.11.1/test/Text/0000755000000000000000000000000012762212723014322 5ustar0000000000000000shakespeare-2.0.11.1/test/Text/CssSpec.hs0000644000000000000000000004102512762212723016223 0ustar0000000000000000{-# LANGUAGE QuasiQuotes #-} {-# LANGUAGE TemplateHaskell #-} {-# OPTIONS_GHC -O0 #-} module Text.CssSpec (spec) where import Test.HUnit hiding (Test) import Test.Hspec import Prelude hiding (reverse) import Text.Cassius import Text.Lucius import Data.List (intercalate) import qualified Data.Text.Lazy as T import qualified Data.Text as TS import qualified Data.List import qualified Data.List as L import Data.Text (Text, pack, unpack) import Data.Monoid (mappend) spec :: Spec spec = do it "cassius" caseCassius it "cassiusFile" caseCassiusFile it "cassius single comment" caseCassiusSingleComment it "cassius leading comment" caseCassiusLeadingComment it "cassiusFileDebug" $ do let var = "var" let selector = "foo" let urlp = (Home, [(pack "p", pack "q")]) flip celper $(cassiusFileDebug "test/cassiuses/external1.cassius") $ concat [ "foo {\n background: #000;\n bar: baz;\n color: #F00;\n}\n" , "bin {\n" , " background-image: url(url);\n" , " bar: bar;\n color: #7F6405;\n fvarx: someval;\n unicode-test: שלום;\n" , " urlp: url(url?p=q);\n}\n" ] {- TODO it "cassiusFileDebugChange" $ do let var = "var" writeFile "test/cassiuses/external2.cassius" "foo\n #{var}: 1" celper "foo{var:1}" $(cassiusFileDebug "test/cassiuses/external2.cassius") writeFile "test/cassiuses/external2.cassius" "foo\n #{var}: 2" celper "foo{var:2}" $(cassiusFileDebug "test/cassiuses/external2.cassius") writeFile "test/cassiuses/external2.cassius" "foo\n #{var}: 1" -} it "comments" $ do -- FIXME reconsider Hamlet comment syntax? celper "" [cassius|/* this is a comment */ /* another comment */ /*a third one*/|] it "cassius pseudo-class" $ flip celper [cassius| a:visited color: blue |] "a:visited{color:blue}" it "ignores a blank line" $ do celper "foo{bar:baz}" [cassius| foo bar: baz |] it "leading spaces" $ celper "foo{bar:baz}" [cassius| foo bar: baz |] it "cassius all spaces" $ celper "h1{color:green }" [cassius| h1 color: green |] it "cassius whitespace and colons" $ do celper "h1:hover{color:green ;font-family:sans-serif}" [cassius| h1:hover color: green font-family:sans-serif |] it "cassius trailing comments" $ celper "h1:hover{color:green ;font-family:sans-serif}" [cassius| h1:hover /* Please ignore this */ color: green /* This is a comment. */ /* Obviously this is ignored too. */ font-family:sans-serif |] it "cassius nesting" $ celper "foo bar{baz:bin}" [cassius| foo bar baz: bin |] it "cassius variable" $ celper "foo bar{baz:bin}" [cassius| @binvar: bin foo bar baz: #{binvar} |] it "cassius trailing semicolon" $ celper "foo bar{baz:bin}" [cassius| @binvar: bin foo bar baz: #{binvar}; |] it "cassius module names" $ do let foo = "foo" dub = 3.14::Double int = -5::Int celper "sel{bar:oof oof 3.14 -5}" [cassius| sel bar: #{Data.List.reverse foo} #{L.reverse foo} #{show dub} #{show int} |] it "single dollar at and caret" $ do celper "sel{att:$@^}" [cassius| sel att: $@^ |] {- celper "sel{att:#{@{^{}" [cassius| sel att: #\{@\{^{ |] -} it "dollar operator" $ do let val = (1, (2, 3)) :: (Integer, (Integer, Integer)) celper "sel{att:2}" [cassius| sel att: #{ show $ fst $ snd val } |] celper "sel{att:2}" [cassius| sel att: #{ show $ fst $ snd $ val} |] it "embedded slash" $ do celper "sel{att:///}" [cassius| sel att: /// |] it "multi cassius" $ do celper "foo{bar:baz;bar:bin}" [cassius| foo bar: baz bar: bin |] it "lucius" $ do let var = "var" let urlp = (Home, [(pack "p", pack "q")]) flip celper [lucius| foo { background: #{colorBlack}; bar: baz; color: #{colorRed}; } bin { background-image: url(@{Home}); bar: bar; color: #{(((Color 127) 100) 5)}; f#{var}x: someval; unicode-test: שלום; urlp: url(@?{urlp}); } |] $ concat [ "foo{background:#000;bar:baz;color:#F00}" , "bin{" , "background-image:url(url);" , "bar:bar;color:#7F6405;fvarx:someval;unicode-test:שלום;" , "urlp:url(url?p=q)}" ] it "lucius file" $ do let var = "var" let urlp = (Home, [(pack "p", pack "q")]) flip celper $(luciusFile "test/cassiuses/external1.lucius") $ concat [ "foo{background:#000;bar:baz;color:#F00}" , "bin{" , "background-image:url(url);" , "bar:bar;color:#7F6405;fvarx:someval;unicode-test:שלום;" , "urlp:url(url?p=q)}" ] it "lucius file debug" caseLuciusFileDebug it "lucius nested" $ do celper "foo bar{baz:bin}" $(luciusFile "test/cassiuses/external-nested.lucius") celper "foo bar {\n baz: bin;\n}\n" $(luciusFileDebug "test/cassiuses/external-nested.lucius") celper "foo bar{baz:bin}" [lucius| foo { bar { baz: bin; } } |] celper "foo1 bar,foo2 bar{baz:bin}" [lucius| foo1, foo2 { bar { baz: bin; } } |] it "lucius charset" $ do celper (concat ["@charset \"utf-8\";" , "#content ul{list-style:none;padding:0 5em}" , "#content ul li{padding:1em 0}" , "#content ul li a{color:#419a56;font-family:'TeXGyreHerosBold',helvetica,arial,sans-serif;font-weight:bold;text-transform:uppercase;white-space:nowrap}" ]) [lucius| @charset "utf-8"; #content ul { list-style: none; padding: 0 5em; li { padding: 1em 0; a { color: #419a56; font-family: 'TeXGyreHerosBold',helvetica,arial,sans-serif; font-weight: bold; text-transform: uppercase; white-space: nowrap; } } } |] it "lucius media" $ do celper "@media only screen{foo bar{baz:bin}}" $(luciusFile "test/cassiuses/external-media.lucius") celper "@media only screen {\n foo bar {\n baz: bin;\n }\n}\n" $(luciusFileDebug "test/cassiuses/external-media.lucius") celper "@media only screen{foo bar{baz:bin}}" [lucius| @media only screen{ foo { bar { baz: bin; } } } |] {- it "cassius removes whitespace" $ do celper "foo{bar:baz}" [cassius| foo bar : baz |] -} it "lucius trailing comments" $ celper "foo{bar:baz}" [lucius|foo{bar:baz;}/* ignored*/|] it "lucius variables" $ celper "foo{bar:baz}" [lucius| @myvar: baz; foo { bar: #{myvar}; } |] it "lucius CDO/CDC tokens" $ celper "*{a:b}" [lucius| |] it "lucius @import statements" $ celper "@import url(\"bla.css\");" [lucius| @import url("bla.css"); |] it "lucius simple escapes" $ celper "*{a:test}" [lucius| * { a: t\65 st; } |] it "lucius bounded escapes" $ celper "*{a:teft}" [lucius| * { a: t\000065ft; } |] it "lucius case-insensitive keywords" $ celper "@media foo {}" [lucius| @MeDIa foo { } |] it "lucius @page statements" $ celper "@page :right{a:b;c:d}" [lucius| @page :right { a:b; c:d; } |] it "lucius @font-face statements" $ celper "@font-face{a:b;c:d}" [lucius| @font-face { a:b; c:d; } |] it "lucius runtime" $ Right (T.pack "foo {\n bar: baz;\n}\n") @=? luciusRT (T.pack "foo { bar: #{myvar}}") [(TS.pack "myvar", TS.pack "baz")] it "lucius runtime variables" $ Right (T.pack "foo {\n bar: baz;\n}\n") @=? luciusRT (T.pack "@dummy: dummy; @myvar: baz; @dummy2: dummy; foo { bar: #{myvar}}") [] it "lucius whtiespace" $ Right (T.pack "@media foo {\n bar {\n baz: bin;\n baz2: bin2;\n }\n}\n") @=? luciusRT (T.pack "@media foo{bar{baz:bin;baz2:bin2}}") [] it "variables inside value" $ celper "foo{foo:XbarY}" [lucius| @bar: bar; foo { foo:X#{bar}Y; } |] it "variables in media selector" $ celper "@media (max-width: 400px){foo{color:red}}" [lucius| @mobileWidth: 400px; @media (max-width: #{mobileWidth}){ foo { color: red; } } |] it "URLs in import" $ celper "@import url(\"suburl\");" [lucius| @import url("@{Sub SubUrl}"); |] it "vars in charset" $ do let charset = "mycharset" celper "@charset mycharset;" [lucius| @charset #{charset}; |] it "keyframes" $ celper "@keyframes mymove {from{top:0px}to{top:200px}}" [lucius| @keyframes mymove { from { top: 0px; } to { top: 200px; } } |] it "prefixed keyframes" $ celper "@-webkit-keyframes mymove {from{top:0px}to{top:200px}}" [lucius| @-webkit-keyframes mymove { from { top: 0px; } to { top: 200px; } } |] it "lucius mixins" $ do let bins = [luciusMixin| bin:bin2; /* FIXME not currently implementing sublocks in mixins foo2 { x: y } */ |] :: Mixin -- No sublocks celper "foo{bar:baz;bin:bin2}foo foo2{x:y}" [lucius| celper "foo{bar:baz;bin:bin2}" [lucius| foo { bar: baz; ^{bins} } |] it "cassius mixins" $ do let bins = [cassiusMixin| bin:bin2 bin3:bin4 |] :: Mixin -- No sublocks celper "foo{bar:baz;bin:bin2}foo foo2{x:y}" [lucius| celper "foo{bar:baz;bin:bin2;bin3:bin4}" [lucius| foo { bar: baz; ^{bins} } |] it "more complicated mixins" $ do let transition val = [luciusMixin| -webkit-transition: #{val}; -moz-transition: #{val}; -ms-transition: #{val}; -o-transition: #{val}; transition: #{val}; |] celper ".some-class{-webkit-transition:all 4s ease;-moz-transition:all 4s ease;-ms-transition:all 4s ease;-o-transition:all 4s ease;transition:all 4s ease}" [lucius| .some-class { ^{transition "all 4s ease"} } |] it "runtime mixin" $ do let bins = [luciusMixin| bin:bin2; /* FIXME not currently implementing sublocks in mixins foo2 { x: y } */ |] :: Mixin -- No sublocks celper "foo{bar:baz;bin:bin2}foo foo2{x:y}" [lucius| Right (T.pack "foo{bar:baz;bin:bin2}") @=? luciusRTMixin (T.pack "foo { bar: baz; ^{bins} }") True [(TS.pack "bins", RTVMixin bins)] it "luciusFileReload mixin" $ do let mixin = [luciusMixin|foo:bar;baz:bin|] flip celper $(luciusFileReload "test/cassiuses/mixin.lucius") $ concat [ "selector {\n foo: bar;\n baz: bin;\n}\n" ] it "cassiusFileReload with import URL" $ do celper "@import url(url);\n" $(cassiusFileReload "test/cassiuses/reload-import.cassius") it "& subblocks" $ celper "foo:bar{baz:bin}" [lucius| foo { &:bar { baz: bin; } } |] describe "font-face #139" $ do it "lucius" $ celper "@font-face{font-family:myFirstFont;src:url(sansation_light.woff)}" [lucius| @font-face { font-family: myFirstFont; src: url(sansation_light.woff); } |] it "cassius" $ celper "@font-face{font-family:myFirstFont;src:url(sansation_light.woff)}" [cassius| @font-face font-family: myFirstFont src: url(sansation_light.woff) |] describe "trailing semicolon in mixin" $ do let someMixin = [luciusMixin|foo:bar|] it "direct in lucius" $ celper "baz{foo:bar}" [lucius| baz { ^{someMixin}; } |] it "implicit in cassius #194" $ celper "baz{foo:bar}" [cassius| baz ^{someMixin} |] data Url = Home | Sub SubUrl data SubUrl = SubUrl render :: Url -> [(Text, Text)] -> Text render Home qs = pack "url" `mappend` showParams qs render (Sub SubUrl) qs = pack "suburl" `mappend` showParams qs showParams :: [(Text, Text)] -> Text showParams [] = pack "" showParams z = pack $ '?' : intercalate "&" (map go z) where go (x, y) = go' x ++ '=' : go' y go' = concatMap encodeUrlChar . unpack -- | Taken straight from web-encodings; reimplemented here to avoid extra -- dependencies. encodeUrlChar :: Char -> String encodeUrlChar c -- List of unreserved characters per RFC 3986 -- Gleaned from http://en.wikipedia.org/wiki/Percent-encoding | 'A' <= c && c <= 'Z' = [c] | 'a' <= c && c <= 'z' = [c] | '0' <= c && c <= '9' = [c] encodeUrlChar c@'-' = [c] encodeUrlChar c@'_' = [c] encodeUrlChar c@'.' = [c] encodeUrlChar c@'~' = [c] encodeUrlChar ' ' = "+" encodeUrlChar y = let (a, c) = fromEnum y `divMod` 16 b = a `mod` 16 showHex' x | x < 10 = toEnum $ x + (fromEnum '0') | x < 16 = toEnum $ x - 10 + (fromEnum 'A') | otherwise = error $ "Invalid argument to showHex: " ++ show x in ['%', showHex' b, showHex' c] celper :: String -> CssUrl Url -> Assertion celper res h = do let x = renderCssUrl render h T.pack res @=? x caseCassius :: Assertion caseCassius = do let var = "var" let urlp = (Home, [(pack "p", pack "q")]) flip celper [cassius| foo background: #{colorBlack} bar: baz color: #{colorRed} bin background-image: url(@{Home}) bar: bar color: #{(((Color 127) 100) 5)} f#{var}x: someval unicode-test: שלום urlp: url(@?{urlp}) |] $ concat [ "foo{background:#000;bar:baz;color:#F00}" , "bin{" , "background-image:url(url);" , "bar:bar;color:#7F6405;fvarx:someval;unicode-test:שלום;" , "urlp:url(url?p=q)}" ] caseCassiusFile :: Assertion caseCassiusFile = do let var = "var" let selector = "foo" let urlp = (Home, [(pack "p", pack "q")]) flip celper $(cassiusFile "test/cassiuses/external1.cassius") $ concat [ "foo{background:#000;bar:baz;color:#F00}" , "bin{" , "background-image:url(url);" , "bar:bar;color:#7F6405;fvarx:someval;unicode-test:שלום;" , "urlp:url(url?p=q)}" ] caseCassiusSingleComment :: Assertion caseCassiusSingleComment = flip celper [cassius| /* this is a comment */ |] "" caseCassiusLeadingComment :: Assertion caseCassiusLeadingComment = flip celper [cassius| /* this is a comment */ sel1 foo: bar sel2 baz: bin |] "sel1{foo:bar}sel2{baz:bin}" instance Show Url where show _ = "FIXME remove this instance show Url" caseLuciusFileDebug :: Assertion caseLuciusFileDebug = do let var = "var" writeFile "test/cassiuses/external2.lucius" "foo{#{var}: 1}" celper "foo {\n var: 1;\n}\n" $(luciusFileDebug "test/cassiuses/external2.lucius") writeFile "test/cassiuses/external2.lucius" "foo{#{var}: 2}" celper "foo {\n var: 2;\n}\n" $(luciusFileDebug "test/cassiuses/external2.lucius") writeFile "test/cassiuses/external2.lucius" "foo{#{var}: 1}" shakespeare-2.0.11.1/test/Text/HamletSpec.hs0000644000000000000000000006706212762212723016716 0ustar0000000000000000{-# LANGUAGE QuasiQuotes #-} {-# LANGUAGE TemplateHaskell #-} module Text.HamletSpec (spec) where import HamletTestTypes (ARecord(..)) import Test.HUnit hiding (Test) import Test.Hspec hiding (Arg) import Prelude hiding (reverse) import Text.Hamlet import Text.Hamlet.RT import Data.List (intercalate) import qualified Data.Text.Lazy as T import qualified Data.List import qualified Data.List as L import Data.Text (Text, pack, unpack) import Data.Monoid (mappend) import qualified Data.Set as Set import qualified Text.Blaze.Html.Renderer.Text import Text.Blaze.Html (toHtml) import Text.Blaze.Internal (preEscapedString) import Text.Blaze spec = do it "empty" caseEmpty it "static" caseStatic it "tag" caseTag it "var" caseVar it "var chain " caseVarChain it "url" caseUrl it "url chain " caseUrlChain it "embed" caseEmbed it "embed chain " caseEmbedChain it "if" caseIf it "if chain " caseIfChain it "else" caseElse it "else chain " caseElseChain it "elseif" caseElseIf it "elseif chain " caseElseIfChain it "list" caseList it "list chain" caseListChain it "with" caseWith it "with multi" caseWithMulti it "with chain" caseWithChain it "with comma string" caseWithCommaString it "with multi scope" caseWithMultiBindingScope it "script not empty" caseScriptNotEmpty it "meta empty" caseMetaEmpty it "input empty" caseInputEmpty it "multiple classes" caseMultiClass it "attrib order" caseAttribOrder it "nothing" caseNothing it "nothing chain " caseNothingChain it "just" caseJust it "just chain " caseJustChain it "constructor" caseConstructor it "url + params" caseUrlParams it "escape" caseEscape it "empty statement list" caseEmptyStatementList it "attribute conditionals" caseAttribCond it "non-ascii" caseNonAscii it "maybe function" caseMaybeFunction it "trailing dollar sign" caseTrailingDollarSign it "non leading percent sign" caseNonLeadingPercent it "quoted attributes" caseQuotedAttribs it "spaced derefs" caseSpacedDerefs it "attrib vars" caseAttribVars it "strings and html" caseStringsAndHtml it "nesting" caseNesting it "trailing space" caseTrailingSpace it "currency symbols" caseCurrency it "external" caseExternal it "parens" caseParens it "hamlet literals" caseHamletLiterals it "hamlet' and xhamlet'" caseHamlet' it "hamlet tuple" caseTuple it "complex pattern" caseComplex it "record pattern" caseRecord it "record wildcard pattern #1" caseRecordWildCard it "record wildcard pattern #2" caseRecordWildCard1 it "comments" $ do -- FIXME reconsider Hamlet comment syntax? helper "" [hamlet|$# this is a comment $# another comment $#a third one|] it "ignores a blank line" $ do helper "

foo

\n" [hamlet|

foo |] it "angle bracket syntax" $ helper "

HELLO

" [hamlet| $newline never HELLO |] it "hamlet module names" $ do let foo = "foo" helper "oof oof 3.14 -5" [hamlet| $newline never #{Data.List.reverse foo} # #{L.reverse foo} # #{show 3.14} #{show -5}|] it "single dollar at and caret" $ do helper "$@^" [hamlet|\$@^|] helper "#{@{^{" [hamlet|#\{@\{^\{|] it "dollar operator" $ do let val = (1, (2, 3)) helper "2" [hamlet|#{ show $ fst $ snd val }|] helper "2" [hamlet|#{ show $ fst $ snd $ val}|] it "in a row" $ do helper "1" [hamlet|#{ show $ const 1 2 }|] it "embedded slash" $ do helper "///" [hamlet|///|] {- compile-time error it "tag with slash" $ do helper "" [hamlet|

Text

|] -} it "string literals" $ do helper "string" [hamlet|#{"string"}|] helper "string" [hamlet|#{id "string"}|] helper "gnirts" [hamlet|#{L.reverse $ id "string"}|] helper "str"ing" [hamlet|#{"str\"ing"}|] helper "str<ing" [hamlet|#{"str1

2 not ignored

" [hamlet| $newline never

1

2 not ignored |] it "Keeps SSI includes" $ helper "" [hamlet||] it "nested maybes" $ do let muser = Just "User" :: Maybe String mprof = Nothing :: Maybe Int m3 = Nothing :: Maybe String helper "justnothing" [hamlet| $maybe user <- muser $maybe profile <- mprof First two are Just $maybe desc <- m3 \ and left us a description:

#{desc} $nothing and has left us no description. $nothing justnothing $nothing

No such Person exists. |] it "maybe with qualified constructor" $ do helper "5" [hamlet| $maybe HamletTestTypes.ARecord x y <- Just $ ARecord 5 True \#{x} |] it "record with qualified constructor" $ do helper "5" [hamlet| $maybe HamletTestTypes.ARecord {..} <- Just $ ARecord 5 True \#{field1} |] it "conditional class" $ do helper "

\n" [hamlet|

|] helper "

\n" [hamlet|

|] helper "

\n" [hamlet|

|] it "forall on Foldable" $ do let set = Set.fromList [1..5 :: Int] helper "12345" [hamlet| $forall x <- set #{x} |] it "non-poly HTML" $ do helperHtml "

HELLO WORLD

\n" [shamlet|

HELLO WORLD |] helperHtml "

HELLO WORLD

\n" $(shamletFile "test/hamlets/nonpolyhtml.hamlet") helper "

HELLO WORLD

\n" $(hamletFileReload "test/hamlets/nonpolyhtml.hamlet") it "non-poly Hamlet" $ do let embed = [hamlet|

EMBEDDED|] helper "

url

\n

EMBEDDED

\n" [hamlet|

@{Home} ^{embed} |] helper "

url

\n" $(hamletFile "test/hamlets/nonpolyhamlet.hamlet") helper "

url

\n" $(hamletFileReload "test/hamlets/nonpolyhamlet.hamlet") it "non-poly IHamlet" $ do let embed = [ihamlet|

EMBEDDED|] ihelper "

Adios

\n

EMBEDDED

\n" [ihamlet|

_{Goodbye} ^{embed} |] ihelper "

Hola

\n" $(ihamletFile "test/hamlets/nonpolyihamlet.hamlet") ihelper "

Hola

\n" $(ihamletFileReload "test/hamlets/nonpolyihamlet.hamlet") it "pattern-match tuples: forall" $ do let people = [("Michael", 26), ("Miriam", 25)] helper "
Michael
26
Miriam
25
" [hamlet| $newline never
$forall (name, age) <- people
#{name}
#{show age} |] it "pattern-match tuples: maybe" $ do let people = Just ("Michael", 26) helper "
Michael
26
" [hamlet| $newline never
$maybe (name, age) <- people
#{name}
#{show age} |] it "pattern-match tuples: with" $ do let people = ("Michael", 26) helper "
Michael
26
" [hamlet| $newline never
$with (name, age) <- people
#{name}
#{show age} |] it "list syntax for interpolation" $ do helper "
  • 1
  • 2
  • 3
" [hamlet| $newline never