6 files changed, 55 insertions, 135 deletions
diff --git a/src/Hakyll/Web/Feed.hs b/src/Hakyll/Web/Feed.hs
index c0a6213..01ba0e1 100644
--- a/src/Hakyll/Web/Feed.hs
+++ b/src/Hakyll/Web/Feed.hs
@@ -24,8 +24,8 @@ module Hakyll.Web.Feed
 
 
 --------------------------------------------------------------------------------
-import           Control.Monad                   (forM, (<=<))
-import           Data.Monoid                     (mconcat)
+import           Control.Monad                 (forM, (<=<))
+import           Data.Monoid                   (mconcat)
 
 
 --------------------------------------------------------------------------------
@@ -34,7 +34,7 @@ import           Hakyll.Core.Compiler.Internal
 import           Hakyll.Core.Item
 import           Hakyll.Web.Template
 import           Hakyll.Web.Template.Context
-import           Hakyll.Web.Template.Read.Hakyll (readTemplate)
+import           Hakyll.Web.Template.Read
 
 
 --------------------------------------------------------------------------------
diff --git a/src/Hakyll/Web/Template.hs b/src/Hakyll/Web/Template.hs
index adaf1aa..a933496 100644
--- a/src/Hakyll/Web/Template.hs
+++ b/src/Hakyll/Web/Template.hs
@@ -36,32 +36,9 @@
 --
 -- Because of it's simplicity, these templates can be used for more than HTML:
 -- you could make, for example, CSS or JS templates as well.
---
--- In addition to the native format, Hakyll also supports hamlet templates. For
--- more information on hamlet templates, please refer to:
--- <http://hackage.haskell.org/package/hamlet>. Internally, hamlet templates are
--- converted to hakyll templates -- which means that you can only use variable
--- insertion (and not all hamlet's features).
---
--- This is an example of a valid hamlet template. You should place them in
--- files with a @.hamlet@ extension:
---
--- > !!!
--- > <html>
--- >     <head>
--- >         <meta charset="UTF-8">
--- >         <title> MyAweSomeCompany - #{title}
--- >     <body>
--- >         <h1> MyAweSomeCompany - #{title}
--- >         <div id="navigation">
--- >             <a href="/index.html"> Home
--- >             <a href="/about.html"> About
--- >             <a href="/code.html"> Code
--- >         #{body}
 module Hakyll.Web.Template
     ( Template
     , templateCompiler
-    , templateCompilerWith
     , applyTemplate
     , applyTemplateWith
     ) where
@@ -70,14 +47,10 @@ module Hakyll.Web.Template
 --------------------------------------------------------------------------------
 import           Control.Monad                (forM, liftM)
 import           Prelude                      hiding (id)
-import           System.FilePath              (takeExtension)
-import           Text.Hamlet                  (HamletSettings,
-                                               defaultHamletSettings)
 
 
 --------------------------------------------------------------------------------
 import           Hakyll.Core.Compiler
-import           Hakyll.Core.Identifier
 import           Hakyll.Core.Item
 import           Hakyll.Web.Template.Context
 import           Hakyll.Web.Template.Internal
@@ -85,25 +58,11 @@ import           Hakyll.Web.Template.Read
 
 
 --------------------------------------------------------------------------------
--- | Read a template. If the extension of the file we're compiling is
--- @.hml@ or @.hamlet@, it will be considered as a Hamlet template, and parsed
--- as such.
+-- | Read a template.
 templateCompiler :: Compiler (Item Template)
-templateCompiler = templateCompilerWith defaultHamletSettings
-
-
---------------------------------------------------------------------------------
--- | Version of 'templateCompiler' that enables custom settings.
-templateCompilerWith :: HamletSettings -> Compiler (Item Template)
-templateCompilerWith settings =
-    cached "Hakyll.Web.Template.templateCompilerWith" $ do
-        identifier <- getUnderlying
-        item       <- getResourceString
-        if takeExtension (toFilePath identifier) `elem` [".hml", ".hamlet"]
-            -- Hamlet template
-            then return $ fmap (readHamletTemplateWith settings) item
-            -- Hakyll template
-            else return $ fmap readTemplate item
+templateCompiler = cached "Hakyll.Web.Template.templateCompiler" $ do
+    item <- getResourceString
+    return $ fmap readTemplate item
 
 
 --------------------------------------------------------------------------------
diff --git a/src/Hakyll/Web/Template/Context.hs b/src/Hakyll/Web/Template/Context.hs
index eeec728..acc01bf 100644
--- a/src/Hakyll/Web/Template/Context.hs
+++ b/src/Hakyll/Web/Template/Context.hs
@@ -4,6 +4,7 @@ module Hakyll.Web.Template.Context
     , mapContext
     , field
     , constField
+    , functionField
 
     , defaultContext
     , bodyField
@@ -71,6 +72,15 @@ constField key = field key . const . return
 
 
 --------------------------------------------------------------------------------
+functionField :: String -> ([String] -> Item a -> Compiler String) -> Context a
+functionField name value = Context $ \k i -> case words k of
+    []              -> empty
+    (n : args)
+        | n == name -> value args i
+        | otherwise -> empty
+
+
+--------------------------------------------------------------------------------
 defaultContext :: Context String
 defaultContext =
     bodyField     "body"     `mappend`
diff --git a/src/Hakyll/Web/Template/Read.hs b/src/Hakyll/Web/Template/Read.hs
index 421b7e9..f8583ff 100644
--- a/src/Hakyll/Web/Template/Read.hs
+++ b/src/Hakyll/Web/Template/Read.hs
@@ -1,10 +1,42 @@
--- | Re-exports all different template reading modules
---
+--------------------------------------------------------------------------------
+-- | Read templates in Hakyll's native format
 module Hakyll.Web.Template.Read
     ( readTemplate
-    , readHamletTemplate
-    , readHamletTemplateWith
     ) where
 
-import Hakyll.Web.Template.Read.Hakyll
-import Hakyll.Web.Template.Read.Hamlet
+
+--------------------------------------------------------------------------------
+import Data.List (isPrefixOf)
+import Data.Char (isAlphaNum)
+
+
+--------------------------------------------------------------------------------
+import Hakyll.Web.Template.Internal
+
+
+--------------------------------------------------------------------------------
+-- | Construct a @Template@ from a string.
+readTemplate :: String -> Template
+readTemplate = Template . readTemplate'
+  where
+    readTemplate' [] = []
+    readTemplate' string
+        | "$$" `isPrefixOf` string =
+            Escaped : readTemplate' (drop 2 string)
+        | "$" `isPrefixOf` string =
+            case readKey (drop 1 string) of
+                Just (key, rest) -> Key key : readTemplate' rest
+                Nothing          -> Chunk "$" : readTemplate' (drop 1 string)
+        | otherwise =
+            let (chunk, rest) = break (== '$') string
+            in Chunk chunk : readTemplate' rest
+
+    -- Parse an key into (key, rest) if it's valid, and return
+    -- Nothing otherwise
+    readKey string =
+        let (key, rest) = span validKeyChar string
+        in if not (null key) && "$" `isPrefixOf` rest
+            then Just (key, drop 1 rest)
+            else Nothing
+
+    validKeyChar x = isAlphaNum x || x == ' '
diff --git a/src/Hakyll/Web/Template/Read/Hakyll.hs b/src/Hakyll/Web/Template/Read/Hakyll.hs
deleted file mode 100644
index fecf772..0000000
--- a/src/Hakyll/Web/Template/Read/Hakyll.hs
+++ /dev/null
@@ -1,35 +0,0 @@
--- | Read templates in Hakyll's native format
---
-module Hakyll.Web.Template.Read.Hakyll
-    ( readTemplate
-    ) where
-
-import Data.List (isPrefixOf)
-import Data.Char (isAlphaNum)
-
-import Hakyll.Web.Template.Internal
-
--- | Construct a @Template@ from a string.
---
-readTemplate :: String -> Template
-readTemplate = Template . readTemplate'
-  where
-    readTemplate' [] = []
-    readTemplate' string
-        | "$$" `isPrefixOf` string =
-            Escaped : readTemplate' (drop 2 string)
-        | "$" `isPrefixOf` string =
-            case readKey (drop 1 string) of
-                Just (key, rest) -> Key key : readTemplate' rest
-                Nothing          -> Chunk "$" : readTemplate' (drop 1 string)
-        | otherwise =
-            let (chunk, rest) = break (== '$') string
-            in Chunk chunk : readTemplate' rest
-
-    -- Parse an key into (key, rest) if it's valid, and return
-    -- Nothing otherwise
-    readKey string =
-        let (key, rest) = span isAlphaNum string
-        in if not (null key) && "$" `isPrefixOf` rest
-            then Just (key, drop 1 rest)
-            else Nothing
diff --git a/src/Hakyll/Web/Template/Read/Hamlet.hs b/src/Hakyll/Web/Template/Read/Hamlet.hs
deleted file mode 100644
index a08cb1d..0000000
--- a/src/Hakyll/Web/Template/Read/Hamlet.hs
+++ /dev/null
@@ -1,46 +0,0 @@
--- | Read templates in the hamlet format
---
-{-# LANGUAGE MultiParamTypeClasses #-}
-module Hakyll.Web.Template.Read.Hamlet
-    ( readHamletTemplate
-    , readHamletTemplateWith
-    ) where
-
-import Text.Hamlet (HamletSettings, defaultHamletSettings)
-import Text.Hamlet.RT
-
-import Hakyll.Web.Template.Internal
-
--- | Read a hamlet template using the default settings
---
-readHamletTemplate :: String -> Template
-readHamletTemplate = readHamletTemplateWith defaultHamletSettings
-
--- | Read a hamlet template using the specified settings
---
-readHamletTemplateWith :: HamletSettings -> String -> Template
-readHamletTemplateWith settings string =
-    let result = parseHamletRT settings string
-    in case result of
-        Just hamlet -> fromHamletRT hamlet
-        Nothing     -> error
-            "Hakyll.Web.Template.Read.Hamlet.readHamletTemplateWith: \
-            \Could not parse Hamlet file"
-
--- | Convert a 'HamletRT' to a 'Template'
---
-fromHamletRT :: HamletRT  -- ^ Hamlet runtime template
-             -> Template  -- ^ Hakyll template
-fromHamletRT (HamletRT sd) = Template $ map fromSimpleDoc sd
-  where
-    fromSimpleDoc :: SimpleDoc -> TemplateElement
-    fromSimpleDoc (SDRaw chunk) = Chunk chunk
-    fromSimpleDoc (SDVar [var]) = Key var
-    fromSimpleDoc (SDVar _) = error
-        "Hakyll.Web.Template.Read.Hamlet.fromHamletRT: \
-        \Hakyll does not support '.' in identifier names when using \
-        \hamlet templates."
-    fromSimpleDoc _ = error
-        "Hakyll.Web.Template.Read.Hamlet.fromHamletRT: \
-        \Only simple $key$ identifiers are allowed when using hamlet \
-        \templates."