ff118fe · hakyll · git.iko.soy

git.iko.soy/hakyll

on master help sign in

Simplify match implementation(s)

ff118feJasper Van der Jeugt16 years ago

src/Hakyll/Core/Routes.hs+5−4

compare with master

unifiedsplit

@@ -41,6 +41,7 @@ import Control.Monad (mplus)

41import System.FilePath (replaceExtension)

43import Hakyll.Core.Identifier

44+import Hakyll.Core.Identifier.Pattern

44import Hakyll.Core.Util.String

45import Hakyll.Core.Util.String

46-- | Type used for a route

47-- | Type used for a route

@@ -84,12 +85,12 @@ setExtension :: String -> Routes

84setExtension extension = Routes $ fmap (`replaceExtension` extension)

85setExtension extension = Routes $ fmap (`replaceExtension` extension)

85 . unRoutes idRoute

86 . unRoutes idRoute

87−-- | Apply the route if the identifier matches the given predicate, fail

88+-- | Apply the route if the identifier matches the given pattern, fail

88-- otherwise

89-- otherwise

89--

90--

90−matchRoute :: (Identifier -> Bool) -> Routes -> Routes

91+matchRoute :: Pattern -> Routes -> Routes

91−matchRoute predicate (Routes route) = Routes $ \id' ->

92+matchRoute pattern (Routes route) = Routes $ \id' ->

92− if predicate id' then route id' else Nothing

93+ if matches pattern id' then route id' else Nothing

94-- | Create a custom route. This should almost always be used with

95-- | Create a custom route. This should almost always be used with

95-- 'matchRoute'

96-- 'matchRoute'

src/Hakyll/Core/Rules.hs+17−19

@@ -7,15 +7,18 @@

7-- A typical usage example would be:

8--

9-- > main = hakyll $ do

10+-- > match "posts/*" $ do

10−-- > route "posts/*" (setExtension "html")

11+-- > route (setExtension "html")

11−-- > compile "posts/*" someCompiler

12+-- > compile someCompiler

13+-- > match "css/*" $ do

14+-- > route idRoute

15+-- > compile compressCssCompiler

12--

16--

13{-# LANGUAGE GeneralizedNewtypeDeriving, OverloadedStrings #-}

17{-# LANGUAGE GeneralizedNewtypeDeriving, OverloadedStrings #-}

14module Hakyll.Core.Rules

18module Hakyll.Core.Rules

15 ( RulesM

19 ( RulesM

16 , Rules

20 , Rules

17− , matchPattern

21+ , match

18− , matchPredicate

19 , compile

22 , compile

20 , create

23 , create

21 , route

24 , route

@@ -28,7 +31,7 @@ import Control.Monad.Writer (tell)

28import Control.Monad.Reader (ask, local)

31import Control.Monad.Reader (ask, local)

29import Control.Arrow (second, (>>>), arr, (>>^))

32import Control.Arrow (second, (>>>), arr, (>>^))

30import Control.Monad.State (get, put)

33import Control.Monad.State (get, put)

31−import Data.Monoid (mempty)

34+import Data.Monoid (mempty, mappend)

32import qualified Data.Set as S

35import qualified Data.Set as S

34import Data.Typeable (Typeable)

37import Data.Typeable (Typeable)

@@ -65,18 +68,13 @@ tellResources :: [Resource]

65 -> Rules

68 -> Rules

66tellResources resources = RulesM $ tell $ RuleSet mempty mempty $ S.fromList resources

69tellResources resources = RulesM $ tell $ RuleSet mempty mempty $ S.fromList resources

68−-- | Only compile/route items matching the given pattern

69−--

70−matchPattern :: Pattern -> Rules -> Rules

71−matchPattern pattern = matchPredicate (doesMatch pattern)

72−

73-- | Only compile/route items satisfying the given predicate

71-- | Only compile/route items satisfying the given predicate

74--

72--

75−matchPredicate :: (Identifier -> Bool) -> Rules -> Rules

73+match :: Pattern -> Rules -> Rules

76−matchPredicate predicate = RulesM . local addPredicate . unRulesM

74+match pattern = RulesM . local addPredicate . unRulesM

77 where

75 where

78 addPredicate env = env

76 addPredicate env = env

79− { rulesMatcher = \id' -> rulesMatcher env id' && predicate id'

77+ { rulesPattern = rulesPattern env `mappend` pattern

80 }

78 }

82-- | Add a compilation rule to the rules.

80-- | Add a compilation rule to the rules.

@@ -88,13 +86,13 @@ matchPredicate predicate = RulesM . local addPredicate . unRulesM

88compile :: (Binary a, Typeable a, Writable a)

86compile :: (Binary a, Typeable a, Writable a)

89 => Compiler Resource a -> Rules

87 => Compiler Resource a -> Rules

90compile compiler = RulesM $ do

88compile compiler = RulesM $ do

91− matcher <- rulesMatcher <$> ask

89+ pattern <- rulesPattern <$> ask

92 provider <- rulesResourceProvider <$> ask

90 provider <- rulesResourceProvider <$> ask

93− let identifiers = filter matcher $ map unResource $ resourceList provider

91+ let ids = filterMatches pattern $ map unResource $ resourceList provider

94 unRulesM $ do

92 unRulesM $ do

95− tellCompilers $ flip map identifiers $ \identifier ->

93+ tellCompilers $ flip map ids $ \identifier ->

96 (identifier, constA (Resource identifier) >>> compiler)

94 (identifier, constA (Resource identifier) >>> compiler)

97− tellResources $ map Resource identifiers

95+ tellResources $ map Resource ids

99-- | Add a compilation rule

97-- | Add a compilation rule

100--

98--

@@ -113,8 +111,8 @@ create identifier compiler = tellCompilers [(identifier, compiler)]

113--

111--

114route :: Routes -> Rules

112route :: Routes -> Rules

115route route' = RulesM $ do

113route route' = RulesM $ do

116− matcher <- rulesMatcher <$> ask

114+ pattern <- rulesPattern <$> ask

117− unRulesM $ tellRoute $ matchRoute matcher route'

115+ unRulesM $ tellRoute $ matchRoute pattern route'

118

116

119-- | Apart from regular compilers, one is also able to specify metacompilers.

117-- | Apart from regular compilers, one is also able to specify metacompilers.

120-- Metacompilers are a special class of compilers: they are compilers which

118-- Metacompilers are a special class of compilers: they are compilers which

src/Hakyll/Core/Rules/Internal.hs+3−2

@@ -20,6 +20,7 @@ import Data.Set (Set)

21import Hakyll.Core.ResourceProvider

22import Hakyll.Core.Identifier

23+import Hakyll.Core.Identifier.Pattern

23import Hakyll.Core.Compiler.Internal

24import Hakyll.Core.Compiler.Internal

24import Hakyll.Core.Routes

25import Hakyll.Core.Routes

25import Hakyll.Core.CompiledItem

26import Hakyll.Core.CompiledItem

@@ -60,7 +61,7 @@ data RuleState = RuleState

60--

61--

61data RuleEnvironment = RuleEnvironment

62data RuleEnvironment = RuleEnvironment

62 { rulesResourceProvider :: ResourceProvider

63 { rulesResourceProvider :: ResourceProvider

63− , rulesMatcher :: Identifier -> Bool

64+ , rulesPattern :: Pattern

64 }

65 }

66-- | The monad used to compose rules

67-- | The monad used to compose rules

@@ -82,5 +83,5 @@ runRules rules provider =

82 where

83 where

83 state = RuleState {rulesMetaCompilerIndex = 0}

84 state = RuleState {rulesMetaCompilerIndex = 0}

84 env = RuleEnvironment { rulesResourceProvider = provider

85 env = RuleEnvironment { rulesResourceProvider = provider

85− , rulesMatcher = const True

86+ , rulesPattern = mempty

86 }

87 }