Hakyll.Core.Identifier.Pattern

As Identifier is used to specify a single item, a Pattern is used to specify a list of items.

In most cases, globs are used for patterns.

A very simple pattern of such a pattern is "foo/bar". This pattern will only match the exact foo/bar identifier.

To match more than one identifier, there are different captures that one can use:

• "*": matches at most one element of an identifier;
• "**": matches one or more elements of an identifier.

Some examples:

• "foo/*" will match "foo/bar" and "foo/foo", but not "foo/bar/qux";
• "**" will match any identifier;
• "foo/**" will match "foo/bar" and "foo/bar/qux", but not "bar/foo";
• "foo/*.html" will match all HTML files in the "foo/" directory.

The capture function allows the user to get access to the elements captured by the capture elements in a glob or regex pattern.

The pattern type

data Pattern

Type that allows matching on identifiers

Instances

Show Pattern

Methods

showsPrec :: Int -> Pattern -> ShowS

show :: Pattern -> String

showList :: [Pattern] -> ShowS

IsString Pattern

Methods

fromString :: String -> Pattern

Monoid Pattern

Methods

mempty :: Pattern

mappend :: Pattern -> Pattern -> Pattern

mconcat :: [Pattern] -> Pattern

Binary Pattern

Methods

put :: Pattern -> Put

get :: Get Pattern

putList :: [Pattern] -> Put

Creating patterns

fromGlob :: String -> Pattern

Parse a pattern from a string

fromList :: [Identifier] -> Pattern

Create a Pattern from a list of Identifiers it should match.

Warning: use this carefully with hasNoVersion and hasVersion. The Identifiers in the list already have versions assigned, and the pattern will then only match the intersection of both versions.

A more concrete example,

fromList ["foo.markdown"] .&&. hasVersion "pdf"

will not match anything! The "foo.markdown" Identifier has no version assigned, so the LHS of .&&. will only match this Identifier with no version. The RHS only matches Identifiers with version set to "pdf" -- hence, this pattern matches nothing.

The correct way to use this is:

fromList $ map (setVersion $ Just "pdf") ["foo.markdown"]

fromRegex :: String -> Pattern

Create a Pattern from a regex

Example:

regex "^foo/[^x]*$

fromVersion :: Maybe String -> Pattern

Create a pattern which matches all items with the given version.

hasVersion :: String -> Pattern

Specify a version, e.g.

"foo/*.markdown" .&&. hasVersion "pdf"

hasNoVersion :: Pattern

Match only if the identifier has no version set, e.g.

"foo/*.markdown" .&&. hasNoVersion

Composing patterns

(.&&.) :: Pattern -> Pattern -> Pattern infixr 3

&& for patterns: the given identifier must match both subterms

(.||.) :: Pattern -> Pattern -> Pattern infixr 2

|| for patterns: the given identifier must match any subterm

complement :: Pattern -> Pattern

Inverts a pattern, e.g.

complement "foo/bar.html"

will match anything except "foo/bar.html"

Applying patterns

matches :: Pattern -> Identifier -> Bool

Check if an identifier matches a pattern

filterMatches :: Pattern -> [Identifier] -> [Identifier]

Given a list of identifiers, retain only those who match the given pattern

Capturing strings

capture :: Pattern -> Identifier -> Maybe [String]

Match a glob or regex pattern against an identifier, generating a list of captures

fromCapture :: Pattern -> String -> Identifier

Create an identifier from a pattern by filling in the captures with a given string

Example:

fromCapture (fromGlob "tags/*") "foo"

Result:

"tags/foo"

fromCaptures :: Pattern -> [String] -> Identifier

Create an identifier from a pattern by filling in the captures with the given list of strings