82d5210 · hakyll · git.iko.soy

src/Hakyll/Core/Compiler.hs−12

compare with master

unifiedsplit

@@ -6,7 +6,6 @@ module Hakyll.Core.Compiler

6 , getUnderlying

7 , makeItem

8 , getRoute

9− , getMetadata

10 , getResourceBody

9 , getResourceBody

11 , getResourceString

10 , getResourceString

12 , getResourceLBS

11 , getResourceLBS

@@ -32,11 +31,9 @@ import System.Environment (getProgName)

32--------------------------------------------------------------------------------

31--------------------------------------------------------------------------------

33import Hakyll.Core.Compiler.Internal

32import Hakyll.Core.Compiler.Internal

34import Hakyll.Core.Compiler.Require

33import Hakyll.Core.Compiler.Require

35−import Hakyll.Core.Dependencies

36import Hakyll.Core.Identifier

34import Hakyll.Core.Identifier

37import Hakyll.Core.Item

35import Hakyll.Core.Item

38import Hakyll.Core.Logger as Logger

36import Hakyll.Core.Logger as Logger

39−import Hakyll.Core.Metadata

40import Hakyll.Core.Provider

37import Hakyll.Core.Provider

41import Hakyll.Core.Routes

38import Hakyll.Core.Routes

42import qualified Hakyll.Core.Store as Store

39import qualified Hakyll.Core.Store as Store

@@ -63,15 +60,6 @@ getRoute identifier = do

63 return $ runRoutes routes identifier

60 return $ runRoutes routes identifier

64

61

65

62

66−

67−--------------------------------------------------------------------------------

68−getMetadata :: Identifier -> Compiler Metadata

69−getMetadata identifier = do

70− provider <- compilerProvider <$> compilerAsk

71− compilerTellDependencies [IdentifierDependency identifier]

72− compilerUnsafeIO $ resourceMetadata provider identifier

73−

74−

75--------------------------------------------------------------------------------

63--------------------------------------------------------------------------------

76-- | Get the body of the underlying resource

64-- | Get the body of the underlying resource

77getResourceBody :: Compiler (Item String)

65getResourceBody :: Compiler (Item String)

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

@@ -25,16 +25,18 @@ module Hakyll.Core.Compiler.Internal

25

26

27--------------------------------------------------------------------------------

28−import Control.Applicative (Alternative (..),

28+import Control.Applicative (Alternative (..),

29− Applicative (..))

29+ Applicative (..), (<$>))

30−import Control.Exception (SomeException, handle)

30+import Control.Exception (SomeException, handle)

31−import Data.Monoid (Monoid (..))

31+import Data.Monoid (Monoid (..))

32

33

34--------------------------------------------------------------------------------

35import Hakyll.Core.Dependencies

36import Hakyll.Core.Identifier

37+import Hakyll.Core.Identifier.Pattern

37import Hakyll.Core.Logger

38import Hakyll.Core.Logger

39+import Hakyll.Core.Metadata

38import Hakyll.Core.Provider

40import Hakyll.Core.Provider

39import Hakyll.Core.Routes

41import Hakyll.Core.Routes

40import Hakyll.Core.Store

42import Hakyll.Core.Store

@@ -127,6 +129,12 @@ instance Applicative Compiler where

127 {-# INLINE (<*>) #-}

129 {-# INLINE (<*>) #-}

128

130

129

131

132+--------------------------------------------------------------------------------

133+instance MonadMetadata Compiler where

134+ getMetadata = compilerGetMetadata

135+ getMatches = compilerGetMatches

136+

137+

130--------------------------------------------------------------------------------

138--------------------------------------------------------------------------------

131runCompiler :: Compiler a -> CompilerRead -> IO (CompilerResult a)

139runCompiler :: Compiler a -> CompilerRead -> IO (CompilerResult a)

132runCompiler compiler read' = handle handler $ unCompiler compiler read'

140runCompiler compiler read' = handle handler $ unCompiler compiler read'

@@ -195,3 +203,20 @@ compilerTellDependencies ds = compilerTell mempty {compilerDependencies = ds}

195compilerTellCacheHits :: Int -> Compiler ()

203compilerTellCacheHits :: Int -> Compiler ()

196compilerTellCacheHits ch = compilerTell mempty {compilerCacheHits = ch}

204compilerTellCacheHits ch = compilerTell mempty {compilerCacheHits = ch}

197{-# INLINE compilerTellCacheHits #-}

205{-# INLINE compilerTellCacheHits #-}

206+

207+

208+--------------------------------------------------------------------------------

209+compilerGetMetadata :: Identifier -> Compiler Metadata

210+compilerGetMetadata identifier = do

211+ provider <- compilerProvider <$> compilerAsk

212+ compilerTellDependencies [IdentifierDependency identifier]

213+ compilerUnsafeIO $ resourceMetadata provider identifier

214+

215+

216+--------------------------------------------------------------------------------

217+compilerGetMatches :: Pattern -> Compiler [Identifier]

218+compilerGetMatches pattern = do

219+ universe <- compilerUniverse <$> compilerAsk

220+ let matching = filterMatches pattern universe

221+ compilerTellDependencies [PatternDependency pattern matching]

222+ return matching

src/Hakyll/Core/Compiler/Require.hs+2−3

@@ -19,6 +19,7 @@ import Hakyll.Core.Dependencies

19import Hakyll.Core.Identifier

20import Hakyll.Core.Identifier.Pattern

21import Hakyll.Core.Item

22+import Hakyll.Core.Metadata

22import Hakyll.Core.Store (Store)

23import Hakyll.Core.Store (Store)

23import qualified Hakyll.Core.Store as Store

24import qualified Hakyll.Core.Store as Store

24

25

@@ -59,9 +60,7 @@ requireBody = fmap itemBody . require

59--------------------------------------------------------------------------------

60--------------------------------------------------------------------------------

60requireAll :: (Binary a, Typeable a) => Pattern -> Compiler [Item a]

61requireAll :: (Binary a, Typeable a) => Pattern -> Compiler [Item a]

61requireAll pattern = do

62requireAll pattern = do

62− universe <- compilerUniverse <$> compilerAsk

63+ matching <- getMatches pattern

63− let matching = filterMatches pattern universe

64− compilerTellDependencies [PatternDependency pattern matching]

65 mapM require matching

64 mapM require matching

66

65

67

66

src/Hakyll/Core/Metadata.hs+20

@@ -1,12 +1,32 @@

1--------------------------------------------------------------------------------

2module Hakyll.Core.Metadata

3 ( Metadata

4+ , MonadMetadata (..)

4 ) where

5 ) where

5

6

7

7--------------------------------------------------------------------------------

8--------------------------------------------------------------------------------

9+import Control.Monad (forM)

8import Data.Map (Map)

10import Data.Map (Map)

9

11

10

12

13+--------------------------------------------------------------------------------

14+import Hakyll.Core.Identifier

15+import Hakyll.Core.Identifier.Pattern

16+

17+

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

18--------------------------------------------------------------------------------

12type Metadata = Map String String

19type Metadata = Map String String

20+

21+

22+--------------------------------------------------------------------------------

23+class Monad m => MonadMetadata m where

24+ getMetadata :: Identifier -> m Metadata

25+ getMatches :: Pattern -> m [Identifier]

26+

27+ getAllMetadata :: Pattern -> m [(Identifier, Metadata)]

28+ getAllMetadata pattern = do

29+ matches' <- getMatches pattern

30+ forM matches' $ \id' -> do

31+ metadata <- getMetadata id'

32+ return (id', metadata)

src/Hakyll/Core/Rules.hs+1

@@ -174,6 +174,7 @@ route route' = Rules $ do

174--------------------------------------------------------------------------------

175-- | Get a list of resources matching the current pattern. This will also set

176-- the correct group to the identifiers.

177+-- TODO: Make this private?

177resources :: Rules [Identifier]

178resources :: Rules [Identifier]

178resources = Rules $ do

179resources = Rules $ do

179 pattern <- rulesPattern <$> ask

180 pattern <- rulesPattern <$> ask

src/Hakyll/Core/Rules/Internal.hs+15−1

@@ -12,8 +12,10 @@ module Hakyll.Core.Rules.Internal

12

13

14--------------------------------------------------------------------------------

15−import Control.Applicative (Applicative)

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

16+import Control.Monad.Reader (ask)

16import Control.Monad.RWS (RWST, runRWST)

17import Control.Monad.RWS (RWST, runRWST)

18+import Control.Monad.Trans (liftIO)

17import qualified Data.Map as M

19import qualified Data.Map as M

18import Data.Monoid (Monoid, mappend, mempty)

20import Data.Monoid (Monoid, mappend, mempty)

19import Data.Set (Set)

21import Data.Set (Set)

@@ -24,6 +26,7 @@ import Hakyll.Core.Compiler.Internal

24import Hakyll.Core.Identifier

26import Hakyll.Core.Identifier

25import Hakyll.Core.Identifier.Pattern

27import Hakyll.Core.Identifier.Pattern

26import Hakyll.Core.Item.SomeItem

28import Hakyll.Core.Item.SomeItem

29+import Hakyll.Core.Metadata

27import Hakyll.Core.Provider

30import Hakyll.Core.Provider

28import Hakyll.Core.Routes

31import Hakyll.Core.Routes

29

32

@@ -70,6 +73,17 @@ newtype Rules a = Rules

70 } deriving (Monad, Functor, Applicative)

73 } deriving (Monad, Functor, Applicative)

71

74

72

75

76+--------------------------------------------------------------------------------

77+instance MonadMetadata Rules where

78+ getMetadata identifier = Rules $ do

79+ provider <- rulesProvider <$> ask

80+ liftIO $ resourceMetadata provider identifier

81+

82+ getMatches pattern = Rules $ do

83+ provider <- rulesProvider <$> ask

84+ return $ filterMatches pattern $ resourceList provider

85+

86+

73--------------------------------------------------------------------------------

87--------------------------------------------------------------------------------

74-- | Run a Rules monad, resulting in a 'RuleSet'

88-- | Run a Rules monad, resulting in a 'RuleSet'

75runRules :: Rules a -> Provider -> IO RuleSet

89runRules :: Rules a -> Provider -> IO RuleSet

src/Hakyll/Web/Template/Context.hs+1

@@ -39,6 +39,7 @@ import Hakyll.Core.Compiler

39import Hakyll.Core.Compiler.Internal

40import Hakyll.Core.Identifier

41import Hakyll.Core.Item

42+import Hakyll.Core.Metadata

42import Hakyll.Core.Provider

43import Hakyll.Core.Provider

43import Hakyll.Core.Util.String (splitAll)

44import Hakyll.Core.Util.String (splitAll)

44import Hakyll.Web.Urls

45import Hakyll.Web.Urls