git.iko.soy/hakyll
on ede51e8 help sign in
hakyll/src/Hakyll/Core/Identifier/Pattern.hs
293 lines 10 kB history raw
1--------------------------------------------------------------------------------
2-- | Module providing pattern matching and capturing on 'Identifier's.
3-- 'Pattern's come in two kinds:
4--
5-- * Simple glob patterns, like @foo\/*@;
6--
7-- * Custom, arbitrary predicates of the type @Identifier -> Bool@.
8--
9-- They both have advantages and disadvantages. By default, globs are used,
10-- unless you construct your 'Pattern' using the 'predicate' function.
11--
12-- A very simple pattern could be, for example, @foo\/bar@. This pattern will
13-- only match the exact @foo\/bar@ identifier.
14--
15-- To match more than one identifier, there are different captures that one can
16-- use:
17--
18-- * @*@: matches at most one element of an identifier;
19--
20-- * @**@: matches one or more elements of an identifier.
21--
22-- Some examples:
23--
24-- * @foo\/*@ will match @foo\/bar@ and @foo\/foo@, but not @foo\/bar\/qux@;
25--
26-- * @**@ will match any identifier;
27--
28-- * @foo\/**@ will match @foo\/bar@ and @foo\/bar\/qux@, but not @bar\/foo@;
29--
30-- * @foo\/*.html@ will match all HTML files in the @foo\/@ directory.
31--
32-- The 'capture' function allows the user to get access to the elements captured
33-- by the capture elements in the pattern.
34--
35-- Like an 'Identifier', a 'Pattern' also has a type parameter. This is simply
36-- an extra layer of safety, and can be discarded using the 'castPattern'
37-- function.
38module Hakyll.Core.Identifier.Pattern
39 ( -- * The pattern type
40 Pattern
42 -- * Creating patterns
43 , fromGlob
44 , fromList
45 , fromRegex
47 -- * Manipulating patterns
48 , complement
49 , withVersion
50 , castPattern
52 -- * Applying patterns
53 , matches
54 , filterMatches
56 -- * Capturing strings
57 , capture
58 , fromCapture
59 , fromCaptures
60 ) where
63--------------------------------------------------------------------------------
64import Control.Applicative (pure, (<$>), (<*>))
65import Control.Arrow ((&&&), (>>>))
66import Control.Monad (msum)
67import Data.Binary (Binary (..), getWord8, putWord8)
68import Data.List (inits, isPrefixOf, tails)
69import Data.Maybe (isJust)
70import Data.Monoid (Monoid, mappend, mempty)
73--------------------------------------------------------------------------------
74import GHC.Exts (IsString, fromString)
75import Text.Regex.TDFA ((=~))
78--------------------------------------------------------------------------------
79import Hakyll.Core.Identifier
82--------------------------------------------------------------------------------
83-- | Elements of a glob pattern
84data GlobComponent
85 = Capture
86 | CaptureMany
87 | Literal String
88 deriving (Eq, Show)
91--------------------------------------------------------------------------------
92instance Binary GlobComponent where
93 put Capture = putWord8 0
94 put CaptureMany = putWord8 1
95 put (Literal s) = putWord8 2 >> put s
97 get = getWord8 >>= \t -> case t of
98 0 -> pure Capture
99 1 -> pure CaptureMany
100 2 -> Literal <$> get
101 _ -> error "Data.Binary.get: Invalid GlobComponent"
104--------------------------------------------------------------------------------
105-- | Type that allows matching on identifiers
106data Pattern a
107 = Everything
108 | Complement (Pattern a)
109 | And (Pattern a) (Pattern a)
110 | Glob [GlobComponent]
111 | List [Identifier a] -- TODO Maybe use a set here
112 | Regex String
113 | Version (Maybe String)
114 deriving (Show)
117--------------------------------------------------------------------------------
118instance Binary (Pattern a) where
119 put Everything = putWord8 0
120 put (Complement p) = putWord8 1 >> put p
121 put (And x y) = putWord8 2 >> put x >> put y
122 put (Glob g) = putWord8 3 >> put g
123 put (List is) = putWord8 4 >> put is
124 put (Regex r) = putWord8 5 >> put r
125 put (Version v) = putWord8 6 >> put v
127 get = getWord8 >>= \t -> case t of
128 0 -> pure Everything
129 1 -> Complement <$> get
130 2 -> And <$> get <*> get
131 3 -> Glob <$> get
132 4 -> List <$> get
133 5 -> Regex <$> get
134 _ -> Version <$> get
137--------------------------------------------------------------------------------
138instance IsString (Pattern a) where
139 fromString = fromGlob
142--------------------------------------------------------------------------------
143instance Monoid (Pattern a) where
144 mempty = Everything
145 mappend = And
148--------------------------------------------------------------------------------
149-- | Parse a pattern from a string
150fromGlob :: String -> Pattern a
151fromGlob = Glob . parse'
152 where
153 parse' str =
154 let (chunk, rest) = break (`elem` "\\*") str
155 in case rest of
156 ('\\' : x : xs) -> Literal (chunk ++ [x]) : parse' xs
157 ('*' : '*' : xs) -> Literal chunk : CaptureMany : parse' xs
158 ('*' : xs) -> Literal chunk : Capture : parse' xs
159 xs -> Literal chunk : Literal xs : []
162--------------------------------------------------------------------------------
163-- | Create a 'Pattern' from a list of 'Identifier's it should match
164fromList :: [Identifier a] -> Pattern a
165fromList = List
168--------------------------------------------------------------------------------
169-- | Create a 'Pattern' from a regex
170--
171-- Example:
172--
173-- > regex "^foo/[^x]*$
174fromRegex :: String -> Pattern a
175fromRegex = Regex
178--------------------------------------------------------------------------------
179-- | Inverts a pattern, e.g.
180--
181-- > complement "foo/bar.html"
182--
183-- will match /anything/ except @\"foo\/bar.html\"@
184complement :: Pattern a -> Pattern a
185complement = Complement
188--------------------------------------------------------------------------------
189-- | Specify a version, e.g.
190--
191-- > "foo/*.markdown" `withVersion` "pdf"
192withVersion :: Pattern a -> String -> Pattern a
193withVersion p v = And p $ Version $ Just v
196--------------------------------------------------------------------------------
197-- | Discard the phantom type parameter
198castPattern :: Pattern a -> Pattern b
199castPattern Everything = Everything
200castPattern (Complement x) = Complement (castPattern x)
201castPattern (And x y) = And (castPattern x) (castPattern y)
202castPattern (Glob g) = Glob g
203castPattern (List l) = List $ map castIdentifier l
204castPattern (Regex r) = Regex r
205castPattern (Version v) = Version v
208--------------------------------------------------------------------------------
209-- | Check if an identifier matches a pattern
210matches :: Pattern a -> Identifier a -> Bool
211matches Everything _ = True
212matches (Complement p) i = not $ matches p i
213matches (And x y) i = matches x i && matches y i
214matches (Glob p) i = isJust $ capture (Glob p) i
215matches (List l) i = i `elem` l
216matches (Regex r) i = toFilePath i =~ r
217matches (Version v) i = identifierVersion i == v
220--------------------------------------------------------------------------------
221-- | Given a list of identifiers, retain only those who match the given pattern
222filterMatches :: Pattern a -> [Identifier a] -> [Identifier a]
223filterMatches = filter . matches
226--------------------------------------------------------------------------------
227-- | Split a list at every possible point, generate a list of (init, tail)
228-- cases. The result is sorted with inits decreasing in length.
229splits :: [a] -> [([a], [a])]
230splits = inits &&& tails >>> uncurry zip >>> reverse
233--------------------------------------------------------------------------------
234-- | Match a glob against a pattern, generating a list of captures
235capture :: Pattern a -> Identifier a -> Maybe [String]
236capture (Glob p) i = capture' p (toFilePath i)
237capture _ _ = Nothing
240--------------------------------------------------------------------------------
241-- | Internal verion of 'capture'
242capture' :: [GlobComponent] -> String -> Maybe [String]
243capture' [] [] = Just [] -- An empty match
244capture' [] _ = Nothing -- No match
245capture' (Literal l : ms) str
246 -- Match the literal against the string
247 | l `isPrefixOf` str = capture' ms $ drop (length l) str
248 | otherwise = Nothing
249capture' (Capture : ms) str =
250 -- Match until the next /
251 let (chunk, rest) = break (== '/') str
252 in msum $ [ fmap (i :) (capture' ms (t ++ rest)) | (i, t) <- splits chunk ]
253capture' (CaptureMany : ms) str =
254 -- Match everything
255 msum $ [ fmap (i :) (capture' ms t) | (i, t) <- splits str ]
258--------------------------------------------------------------------------------
259-- | Create an identifier from a pattern by filling in the captures with a given
260-- string
261--
262-- Example:
263--
264-- > fromCapture (parseGlob "tags/*") "foo"
265--
266-- Result:
267--
268-- > "tags/foo"
269fromCapture :: Pattern a -> String -> Identifier a
270fromCapture pattern = fromCaptures pattern . repeat
273--------------------------------------------------------------------------------
274-- | Create an identifier from a pattern by filling in the captures with the
275-- given list of strings
276fromCaptures :: Pattern a -> [String] -> Identifier a
277fromCaptures (Glob p) = fromFilePath . fromCaptures' p
278fromCaptures _ = error $
279 "Hakyll.Core.Identifier.Pattern.fromCaptures: fromCaptures only works " ++
280 "on simple globs!"
283--------------------------------------------------------------------------------
284-- | Internally used version of 'fromCaptures'
285fromCaptures' :: [GlobComponent] -> [String] -> String
286fromCaptures' [] _ = mempty
287fromCaptures' (m : ms) [] = case m of
288 Literal l -> l `mappend` fromCaptures' ms []
289 _ -> error $ "Hakyll.Core.Identifier.Pattern.fromCaptures': "
290 ++ "identifier list exhausted"
291fromCaptures' (m : ms) ids@(i : is) = case m of
292 Literal l -> l `mappend` fromCaptures' ms ids
293 _ -> i `mappend` fromCaptures' ms is