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 the 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 against a pattern, 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