hakyll-4.9.7.0: A static website compiler library

Safe Haskell | None
Language | Haskell98

Hakyll.Core.Identifier.Pattern

Contents

- The pattern type
- Creating patterns
- Composing patterns
- Applying patterns
- Capturing strings

Description

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.

Synopsis

- data Pattern
- fromGlob :: String -> Pattern
- fromList :: [Identifier] -> Pattern
- fromRegex :: String -> Pattern
- fromVersion :: Maybe String -> Pattern
- hasVersion :: String -> Pattern
- hasNoVersion :: Pattern
- (.&&.) :: Pattern -> Pattern -> Pattern
- (.||.) :: Pattern -> Pattern -> Pattern
- complement :: Pattern -> Pattern
- matches :: Pattern -> Identifier -> Bool
- filterMatches :: Pattern -> [Identifier] -> [Identifier]
- capture :: Pattern -> Identifier -> Maybe [String]
- fromCapture :: Pattern -> String -> Identifier
- fromCaptures :: Pattern -> [String] -> Identifier

# 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 `Identifier`s it should match.

Warning: use this carefully with `hasNoVersion` and `hasVersion`. The `Identifier`s 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 `Identifier`s 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