Download the PHP package pattern-lab/patternengine-twig without Composer

Twig PatternEngine for Pattern Lab

The Twig PatternEngine allows you to use Twig as the template language for Pattern Lab PHP. Once the PatternEngine is installed you can use Twig-based StarterKits and StyleguideKits.

Installation

The Twig PatternEngine comes pre-installed with the Pattern Lab Standard Edition for Twig. Please start there for all your Twig needs.

Composer

Pattern Lab PHP uses Composer to manage project dependencies with Pattern Lab Editions. To add the Twig PatternEngine to the dependencies list for your Edition you can type the following in the command line at the base of your project:

composer require pattern-lab/patternengine-twig

See Packagist for information on the latest release.

Overview

This document is broken into three parts:

• Working with Patterns and Twig
• Extending Twig Further
• Available Loaders for Plugin Developers

Working with Patterns and Twig

Twig provides access to two features that may help you extend your patterns, macros and layouts viatemplate inheritance. The Twig PatternEngine also supports the pattern partial syntax to make including one pattern within another very easy.

• Pattern includes
• Macros
• Template inheritance

Pattern includes

Pattern includes take advantage of the pattern partial syntax as a shorthand for referencing patterns from across the system without needing to rely on absolute paths. The format:

For example, let's say we wanted to include the following pattern in a molecule:

The pattern type is atoms (from 00-atoms) and the pattern name is landscape-16x9 from (from 02-landscape-16x9.twig). Pattern sub-types are never used in this format and any digits for re-ordering are dropped. The shorthand partial syntax for this pattern would be:

Macros

The requirements for using macros with Pattern Lab:

• Files must go in source/_macros
• Files must have the extension .macro.twig (this can be modified in the config)
• The filename will be used as the base variable name in Twig templates

Please note: ensure that there is no overlap between the keys for your macros and the keys for your data attributes. A macro with the name forms.macro.twig will conflict with a root key with the name forms in your JSON/YAML. Both are accessed via {{ forms }} in Twig.

An example of a simple macro called forms.macro.twig in source/_macros:

Would be used like this in a pattern:

Template inheritance

How to use Template Inheritance with Pattern Lab:

• Files must have the extension .twig.
• Files can be extended either by using Pattern Lab's normal shorthand syntax (e.g, {% extends 'templates-extended-layout'%}).
• Files can optionally go in source/_layouts in order to hide them from the list of patterns and then you can just use the filename as reference (e.g., {% extends 'extended-layout'%}).
• Files that are in the same directory can also just use the file name without the shorthand syntax (however, it must include the extension). So if file1.twig and file2.twig were in same directory, you could place this code in file2.twig: {% extends 'file1.twig' %}.

An example of a simple layout called base.twig in source/_layouts:

Would be used like this in a pattern:

All uses of extends above also work with includes, embed and most likely many other Twig Tags. Let us know if you run into interesting or unexpected use cases!

Extending Twig Further

Twig comes with a number of ways to extend the underlying template parser. You can you can add extra tags, filters, tests, and functions. The Twig PatternEngine tries to simplify these extensions by allowing you to create files in specific folders and then auto-load the extensions for you. Learn more about:

• Filters
• Functions
• Tags
• Tests

You can also:

• Enable dump()
• Modify the Default Date and Interval Formats
• Quickly disable extensions

Filters

The requirements for using filters with Pattern Lab:

• Files must go in source/_twig-components/filters
• Files must have the extension .filter.php (this can be modified in the config)
• The filter must set the variable $filter
• Only one filter per file (e.g. can only set $filter once per file)

An example function called rot13.filter.php in source/_twig-components/filters:

This filter would be used like this in a pattern:

Functions

The requirements for using functions with Pattern Lab:

• Files must go in source/_twig-components/functions
• Files must have the extension .function.php (this can be modified in the config)
• The function must set the variable $function
• Only one function per file (e.g. can only set $function once per file)

An example function called boo.function.php in source/_twig-components/functions:

This function would be used like this in a pattern:

Tests

The requirements for using tests with Pattern Lab:

• Files must go in source/_twig-components/tests
• Files must have the extension .test.php (this can be modified in the config)
• The test must set the variable $test
• Only one test per file (e.g. can only set $test once per file)

An example of a simple test called red.test.php in source/_twig-components/tests:

This test would be used like this in a pattern:

Where the JSON for the data to set shirt would be:

Reminder: all data in Pattern Lab is stored as an array and not as an object. So $object->attribute won't work in tests.

Tags

The requirements for using tags with Pattern Lab:

• Files must go in source/_twig-components/tags
• Files must have the extension .tag.php (this can be modified in the config)
• The filename must be reflected in class names. (e.g. Project_{filename}_Node and Project_{filename}_TokenParser)
• Only one tag per file

Tags are the most complicated extension to set-up with Pattern Lab. Three steps are needed to define a new tag in Twig:

• Defining a Token Parser class (responsible for parsing the template code)
• Defining a Node class (responsible for converting the parsed code to PHP)
• Registering the tag.

Pattern Lab takes care of the registering for you based on the file name.

An example of a simple tag called setdupe.tag.php in source/_twig-components/tags that mimics the default set tag. Please note all of the locations where class names incorporate the filename, setdupe.

This tag would be used like this in a pattern:

Adding a custom Twig Extension

A Twig Extension is a collection of Twig functions, filters, tags, globals, and tests all as a single bundle. This approach is more advanced than adding a single function or filter using the above method, but allows greater flexibility as the whole Twig Extension can be installed in multiple environments.

To add a Twig Extension using the PHP class \MyProject\MyCustomTwigExtension, add this to config.yml:

What happens under the hood is basically this:

If two Twig Extensions declare a function, filter, etc; the later ones override earlier ones. Any ones declared in Pattern Lab's _twig-components folder will override any declared using this method of custom Twig Extensions.

For an example of how this works, see ExampleTwigExtension.php in this repo. You can enable it by adding this to your config.yml:

Then place this in any Twig file:

That function declaration looks like this in ExampleTwigExtension.php:

An incredible amount of exciting possibilities are enabled with this; have fun!

Enable dump()

To use dump() set twigDebug in config/config.yml to true.

Modify the Default Date and Interval Formats

You can modify the default date and interval formats for Twig by editing the twigDefaultDateFormat and twigDefaultIntervalFormat in config/config.yml. Set them to an empty string to use Twig's default formats. Please note: both must be set for this feature to work.

Quickly Disable Extensions

To disable extensions that you're no longer using simply add an underscore to the beginning of a filename and then re-generate your site. For example, the enabled rot13 filter:

source/_twig-components/filters/rot13.filter.php

And the disabled rot13 filter:

source/_twig-components/filters/_rot13.filter.php

Then re-generate your Pattern Lab site with:

php core/console --generate

Available Loaders

If you're building a plugin that will be parsing Twig files you have access to three loaders. It's recommended that you use these instead of accessing Twig directly as these loaders will work with other PatternEngines.

The String Loader

The string loader takes a simple string and compiles it. To use:

The Filesystem Loader

The filesystem loader will look for templates in the configured StyleguideKit directory and compile them. The template location for the filesystem loader can't be modified. To use:

The Pattern Loader

The pattern loader looks for patterns and allows the use of the Pattern Lab-specific partial syntax. To use: