4100083 · hakyll · git.iko.soy

git.iko.soy/hakyll

Style changes, move stuff to common parser module

commit4100083709a894225717dbe3068f73057e908dd6 authorJasper Van der Jeugt <m@jaspervdj.be> dateSat 4 May 2013, 11:36 (13 years ago) parent28bc3f1

7 files changed+83−49

compare with master

unifiedsplit

hakyll.cabal+1 src/Hakyll/Core/Compiler/Internal.hs+4−3 src/Hakyll/Core/Provider/Metadata.hs+6−1 src/Hakyll/Core/Util/Parser.hs+25 src/Hakyll/Web/Template.hs+7−6 src/Hakyll/Web/Template/Internal.hs+11−11 src/Hakyll/Web/Template/Read.hs+29−28

hakyll.cabal+1

@@ -131,6 +131,7 @@ Library

131131 Hakyll.Core.Runtime

132132 Hakyll.Core.Store

133133 Hakyll.Core.Util.File

134+ Hakyll.Core.Util.Parser

134135 Hakyll.Web.Template.Internal

135136 Paths_hakyll

136137

src/Hakyll/Core/Compiler/Internal.hs+4−3

@@ -1,9 +1,9 @@

11--------------------------------------------------------------------------------

22-- | Internally used compiler module

3+{-# LANGUAGE FlexibleInstances #-}

34{-# LANGUAGE GADTs #-}

45{-# LANGUAGE GeneralizedNewtypeDeriving #-}

5−{-# LANGUAGE FlexibleInstances #-}

6−{-# LANGUAGE MultiParamTypeClasses #-}

6+{-# LANGUAGE MultiParamTypeClasses #-}

77module Hakyll.Core.Compiler.Internal

88 ( -- * Types

99 CompilerRead (..)

@@ -31,7 +31,7 @@ import Control.Applicative (Alternative (..),

3131 Applicative (..), (<$>))

3232import Control.Exception (SomeException, handle)

3333import Control.Monad (forM_)

34−import Control.Monad.Error

34+import Control.Monad.Error (MonadError (..))

3535import Data.Monoid (Monoid (..))

3636import Data.Set (Set)

3737import qualified Data.Set as S

@@ -149,6 +149,7 @@ instance MonadMetadata Compiler where

149149 getMetadata = compilerGetMetadata

150150 getMatches = compilerGetMatches

151151

152+

152153--------------------------------------------------------------------------------

153154instance MonadError [String] Compiler where

154155 throwError = compilerThrow

src/Hakyll/Core/Provider/Metadata.hs+6−1

@@ -4,6 +4,9 @@ module Hakyll.Core.Provider.Metadata

44 ( loadMetadata

55 , metadata

66 , page

8+ -- This parser can be reused in some places

9+ , metadataKey

710 ) where

811

912

@@ -23,6 +26,7 @@ import Text.Parsec.String (Parser)

2326import Hakyll.Core.Identifier

2427import Hakyll.Core.Metadata

2528import Hakyll.Core.Provider.Internal

29+import Hakyll.Core.Util.Parser

2630import Hakyll.Core.Util.String

2731

2832

@@ -93,7 +97,8 @@ newline = P.string "\n" <|> P.string "\r\n"

9397-- | Parse a single metadata field

9498metadataField :: Parser (String, String)

9599metadataField = do

96− key <- P.manyTill P.alphaNum $ P.char ':'

100+ key <- metadataKey

101+ _ <- P.char ':'

97102 P.skipMany1 inlineSpace <?> "space followed by metadata for: " ++ key

98103 value <- P.manyTill P.anyChar newline

99104 trailing' <- P.many trailing

src/Hakyll/Core/Util/Parser.hsnew file+25

@@ -0,0 +1,25 @@

1+--------------------------------------------------------------------------------

2+-- | Parser utilities

3+module Hakyll.Core.Util.Parser

4+ ( metadataKey

5+ , reservedKeys

6+ ) where

9+--------------------------------------------------------------------------------

10+import Control.Applicative ((<$>), (<*>), (<|>))

11+import Control.Monad (mzero)

12+import qualified Text.Parsec as P

13+import Text.Parsec.String (Parser)

14+

15+

16+--------------------------------------------------------------------------------

17+metadataKey :: Parser String

18+metadataKey = do

19+ i <- (:) <$> P.letter <*> (P.many $ P.alphaNum <|> P.oneOf " _-.")

20+ if i `elem` reservedKeys then mzero else return i

21+

22+

23+--------------------------------------------------------------------------------

24+reservedKeys :: [String]

25+reservedKeys = ["if", "else","endif"]

src/Hakyll/Web/Template.hs+7−6

@@ -116,14 +116,15 @@ applyAsTemplate context item =

116116applyTemplateWith :: MonadError e m

117117 => (String -> a -> m String)

118118 -> Template -> a -> m String

119−applyTemplateWith context tpl x = go tpl where

120−

119+applyTemplateWith context tpl x = go tpl

120+ where

121121 go = liftM concat . mapM applyElem . unTemplate

122122

123123 applyElem (Chunk c) = return c

124124 applyElem Escaped = return "$"

125125 applyElem (Key k) = context k x

126− applyElem (If k t mf) = (context k x >> go t) `catchError` handler where

127− handler _ = case mf of

128− Nothing -> return ""

129− Just f -> go f

126+ applyElem (If k t mf) = (context k x >> go t) `catchError` handler

127+ where

128+ handler _ = case mf of

129+ Nothing -> return ""

130+ Just f -> go f

src/Hakyll/Web/Template/Internal.hs+11−11

@@ -22,8 +22,7 @@ import Hakyll.Core.Writable

2222-- | Datatype used for template substitutions.

2323newtype Template = Template

2424 { unTemplate :: [TemplateElement]

25− }

26− deriving (Show, Eq, Binary, Typeable)

25+ } deriving (Show, Eq, Binary, Typeable)

2726

2827

2928--------------------------------------------------------------------------------

@@ -41,17 +40,18 @@ data TemplateElement

4140 | If String Template (Maybe Template) -- key, then branch, else branch

4241 deriving (Show, Eq, Typeable)

4342

43+

4444--------------------------------------------------------------------------------

4545instance Binary TemplateElement where

4646 put (Chunk string) = putWord8 0 >> put string

47− put (Key key) = putWord8 1 >> put key

48− put (Escaped) = putWord8 2

49− put (If key t f) = putWord8 3 >> put key >> put t >> put f

47+ put (Key key) = putWord8 1 >> put key

48+ put (Escaped) = putWord8 2

49+ put (If key t f) = putWord8 3 >> put key >> put t >> put f

5050

5151 get = getWord8 >>= \tag -> case tag of

52− 0 -> Chunk <$> get

53− 1 -> Key <$> get

54− 2 -> pure Escaped

55− 3 -> If <$> get <*> get <*> get

56− _ -> error $ "Hakyll.Web.Template.Internal: "

57− ++ "Error reading cached template"

52+ 0 -> Chunk <$> get

53+ 1 -> Key <$> get

54+ 2 -> pure Escaped

55+ 3 -> If <$> get <*> get <*> get

56+ _ -> error $

57+ "Hakyll.Web.Template.Internal: Error reading cached template"

src/Hakyll/Web/Template/Read.hs+29−28

@@ -4,56 +4,57 @@ module Hakyll.Web.Template.Read

44 ( readTemplate

55 ) where

78--------------------------------------------------------------------------------

8−import Control.Applicative ((<$>), (<$), (<*>))

9−import Control.Monad (void, mzero)

9+import Control.Applicative ((<$), (<$>))

10+import Control.Monad (void)

1011import Text.Parsec

1112import Text.Parsec.String

1213

14+

1315--------------------------------------------------------------------------------

16+import Hakyll.Core.Util.Parser

1417import Hakyll.Web.Template.Internal

1518

16−--------------------------------------------------------------------------------

1719

20+--------------------------------------------------------------------------------

1821readTemplate :: String -> Template

19−readTemplate input =

20− case parse template "" input of

22+readTemplate input = case parse template "" input of

2123 Left err -> error $ "Cannot parse template: " ++ show err

2224 Right t -> t

2325

26+

27+--------------------------------------------------------------------------------

2428template :: Parser Template

25−template = Template <$>

26− (many1 $ chunk <|> escaped <|> conditional <|> key)

29+template = Template <$> (many1 $ chunk <|> escaped <|> conditional <|> key)

30+

2731

32+--------------------------------------------------------------------------------

2833chunk :: Parser TemplateElement

2934chunk = Chunk <$> (many1 $ noneOf "$")

3035

36+

37+--------------------------------------------------------------------------------

3138escaped :: Parser TemplateElement

3239escaped = Escaped <$ (try $ string "$$")

3340

41+

42+--------------------------------------------------------------------------------

3443conditional :: Parser TemplateElement

3544conditional = try $ do

36− void $ string "$if("

37− i <- ident

38− void $ string ")$"

39− thenBranch <- template

40− elseBranch <- optionMaybe $ try (string "$else$") >> template

41− void $ string "$endif$"

42− return $ If i thenBranch elseBranch

43−

44−ident :: Parser String

45−ident = do

46− i <- (:) <$> letter <*> (many $ alphaNum <|> oneOf " _-.")

47− if i `elem` reserved

48− then mzero

49− else return i

50−

51−reserved :: [String]

52−reserved = ["if", "else","endif"]

45+ void $ string "$if("

46+ i <- metadataKey

47+ void $ string ")$"

48+ thenBranch <- template

49+ elseBranch <- optionMaybe $ try (string "$else$") >> template

50+ void $ string "$endif$"

51+ return $ If i thenBranch elseBranch

52+

5353

54+--------------------------------------------------------------------------------

5455key :: Parser TemplateElement

5556key = try $ do

56− void $ char '$'

57− k <- ident

58− void $ char '$'

59− return $ Key k

57+ void $ char '$'

58+ k <- metadataKey

59+ void $ char '$'

60+ return $ Key k