\n\t\n\n\n{% endverbatim %}\n```\nThen create a template that extends base.html, call it \"home.html\":\n```twig\n{% verbatim %}\n{% extends \"base.html\" %}\n\n{% block title %} Home {% endblock %}\n\n{% block content %}\n\t
Home
\n\t
Welcome to my home page. My name is {{ name }}.
\n{% endblock %}\n{% endverbatim %}\n```\nNow we want to compile the template, and render it:\n```java\nPebbleEngine engine = new PebbleEngine.Builder().build();\nPebbleTemplate compiledTemplate = engine.getTemplate(\"home.html\");\n\nMap context = new HashMap<>();\ncontext.put(\"name\", \"Mitchell\");\n\nWriter writer = new StringWriter();\ncompiledTemplate.evaluate(writer, context);\n\nString output = writer.toString();\n```\nThe output should result in the following:\n```twig\n\n\n\t Home \n\n\n\t
\n\t\t
Home
\n\t
Welcome to my home page. My name is Mitchell.
\n\t
\n\t\n\n\n```\n\nFor more information on installation and configuration, see {{ anchor('the installation guide', 'Installation and Configuration') }}. \nFor more information on basic usage, see {{ anchor('the basic usage guide', 'Basic Usage') }}. \nFor Spring Boot integration, see {{ anchor('the Spring Boot integration guide', 'Spring Boot Integration') }}."
},
{
"path": "docs/src/orchid/resources/pages/CNAME",
"content": "---\nrenderMode: raw\nusePrettyUrl: false\n---\npebbletemplates.io"
},
{
"path": "docs/src/orchid/resources/pages/changelog.md",
"content": "---\ncomponents:\n - type: changelog\n---\n"
},
{
"path": "docs/src/orchid/resources/pages/contributing.md",
"content": "---\n---\n\n# Contributing\n\n## Help Wanted\nContributors of all types are welcome but most importantly I am looking for help with the following:\n\n- IDE Integration\n- API Feedback\n- Testing and Bug Reports\n- Performance Optimizations\n- Improving Thread Safety\nGeneral improvements are welcome, otherwise you can help tackle some of the [known issues](https://github.com/PebbleTemplates/pebble/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc).\n\n## Getting Started\n- Fork the [repository](https://github.com/PebbleTemplates/pebble)\n- Make the fix.\n- Use maven to build and test:\n - `mvn clean install` from root to build Pebble\n - `mvn orchid:serve -P doc` from `docs/` to build and serve documentation on http://localhost:8080\n- Submit a pull request\n\n## Understanding the Code\nThere are a few major components that play a vital role in the compilation process. The main\n`PebbleEngine`, the `LexerImpl`, and the `ParserImpl`.\n\nThe `PebbleEngine` is responsible for beginning the template compilation process. It begins by passing\nthe template source to the `Lexer`.\n\nThe `Lexer` is responsible for converting the template into a bunch of `Token` objects. A token is the smallest\ndistinguishable unit in a template, i.e. it can not be broken down into more specific objects. A token can\nrepresent a delimiter (eg. `{{ '{{' }}` ), or a function name, a string, plain text, or many other things. Once the\nlexer has established the entire stream of tokens which collectively make up the entire template, it returns\nthis `TokenStream` back to the main `PebbleEngine`.\n\nThe `PebbleEngine` now sends the `TokenStream` to the `Parser` which is responsible for turning those token objects\ninto `Node` objects. The nodes are built in a hierarchical fashion and together they make up the abstract\nsyntax tree. The parser uses the help of the main `ExpressionParser` as well as the `TokenParser` objects which\nare provided by the\textensions. Each node is responsible for rendering itself during the template\nevaluation phase.\n\nThe `PebbleEngine` now has a tree of node objects, beginning with the `NodeRoot`. It will then create a\n`PebbleTemplateImpl` object with this root node as an argument. The last step before returning this template\nto the user is to invoke both the internal and the user-provided `NodeVisitor` objects on the node tree.\nNode visitors are used to process the node tree, perhaps to add extra functionality (ex. the built-in\nautoescaper uses a node visitor to wrap the expressions of nodes with an escape function). Once this\nprocessing is completed, the template is placed into the cache and finally returned to the user.\n\nThe user will then call `evaluate()` on this template which begins the evaluation process. The template\nwill call `render()` on it's root node which in turn will call `render()` on each of it's children nodes.\nThis process recurses throughout the whole node tree until all nodes have rendered themselves to the\nprovided `Writer` object.\n\n## Documentation\n\nThe documentation website is generated using [Orchid](https://orchid.netlify.com/). \n\nThe documentation files are under the `src/orchid/resources` directory.\n\n## Contributing Code\nCurrently there aren't any formal guidelines. Just ensure that your changes include any\nnecessary unit tests and send me a pull request on [github](https://github.com/PebbleTemplates/pebble)!\n\n## Standards and Guidelines\n\n### Code Formatting Standards\n\n1. Use [Google Style Guide](https://google.github.io/styleguide/javaguide.html) formatting conventions.\n 1. Configuring IntelliJ to use the Google Style Guide Formatter.\n 1. Clone the [Google Style Git Repo](https://github.com/google/styleguide).\n 2. Open **Preferences -> Editor -> Code Style -> Java**. \n 4. Click on the gear and select **Import Scheme -> IntelliJ IDEA code style XML** and import the file **intellij-java-google-style.xml** from the [Google Style Git Repo](https://github.com/google/styleguide).\n 2. Configuring Eclipse to use the Google Style Guide Formatter.\n 1. Clone the [Google Style Git Repo](https://github.com/google/styleguide).\n 2. Select **Preference -> Java -> Code Style -> Formatter**.\n 3. Select **Import** and specify the file **eclipse-java-google-style.xml** from the [Google Style Git Repo](https://github.com/google/styleguide).\n\n### Unit Test Guidelines\n\n1. Use [AssertJ]() for all Unit and Integration tests. \n2. A javadoc description should be included for each test method.\n3. The purpose of each test should be clear from the test method name.\n\n## Acknowledgements\nThanks to all the following contributors who are helping to make Pebble the best template engine available for Java. \n\n{%- for contributor in data.contributors %}\n* [{{ contributor.name }}]({{ contributor.link }})\n{%- endfor %}\n"
},
{
"path": "docs/src/orchid/resources/pages/twig-compatibility.peb",
"content": "---\ntitle: Twig Compatibility\n---\n\nWhile Pebble was inspired by and generally has high compatibility with Twig, it is neither a complete nor an exact Twig\nimplementation. There are features of Twig not supported by Pebble, there are features implemented in Pebble that are\nnot supported by Twig, and some features might behave differently or use a different name or syntax. This page outlines\nthe similarities and differences between Pebble and Twig.\n\n{{ compat('Tags', data['twig-compatibility'].tags ) }}\n{{ compat('Filters', data['twig-compatibility'].filters ) }}\n{{ compat('Functions', data['twig-compatibility'].functions ) }}\n{{ compat('Tests', data['twig-compatibility'].tests ) }}\n{{ compat('Operators', data['twig-compatibility'].operators ) }}\n\n{% macro compat(type, items) %}\n \n \n
\n \n\n \n \n {% if not page.menu.isEmpty() %}\n \n {% endif %}\n\n \n \n
\n Currently {{ site.version }}.\n
\n \n\n \n \n\n
\n
"
},
{
"path": "docs/src/orchid/resources/templates/layouts/index.peb",
"content": "\n\n\n\n{% include '?trackingHeadStart' %}\n{% head %}\n\n\n{% styles %}\n{% include '?trackingHeadEnd' %}\n\n\n{% include '?trackingBodyStart' %}\n\n\n
\n\n{% scripts %}\n\n{% include '?trackingBodyEnd' %}\n\n"
},
{
"path": "docs/src/orchid/resources/wiki/filter/abbreviate.md",
"content": "# `abbreviate`\nThe `abbreviate` filter will abbreviate a string using an ellipsis. It takes one argument which is the max\nwidth of the desired output including the length of the ellipsis.\n```twig\n{{ \"this is a long sentence.\" | abbreviate(7) }}\n```\nThe above example will output the following:\n```twig\nthis...\n```\n\n## Arguments\n- length"
},
{
"path": "docs/src/orchid/resources/wiki/filter/abs.md",
"content": "# `abs`\nThe `abs` filter is used to obtain the absolute value.\n\n```twig\n{{ -7 | abs }}\n\n{# output: 7 #}\n```"
},
{
"path": "docs/src/orchid/resources/wiki/filter/base64decode.md",
"content": "---\n---\n\n# `base64decode`\nThe `base64decode` filter takes the given input, Base64-decodes it, if possible, and returns the byte array converted to UTF-8 String.\nApplying the filter on an incorrect base64-encoded string will throw an exception. \n\n```twig\n{% verbatim %}{{ \"dGVzdA==\" | base64decode }}{% endverbatim %}\n```\nThe above example will output the following:\n```\ntest\n```"
},
{
"path": "docs/src/orchid/resources/wiki/filter/base64encode.md",
"content": "---\n---\n\n# `base64encode`\nThe `base64encode` filter takes the given input, converts it to an UTF-8 String (`.toString()`) and Base64-encodes it.\n\n```twig\n{% verbatim %}{{ \"test\" | base64encode }}{% endverbatim %}\n```\nThe above example will output the following:\n```\ndGVzdA==\n```\n"
},
{
"path": "docs/src/orchid/resources/wiki/filter/capitalize.md",
"content": "---\n---\n\n# `capitalize`\nThe `capitalize` filter will capitalize the first letter of the string.\n```twig\n{% verbatim %}\n{{ \"article title\" | capitalize }}\n{% endverbatim %}\n```\nThe above example will output the following:\n```twig\nArticle title\n```\nSee also: {{ anchor('title') }}"
},
{
"path": "docs/src/orchid/resources/wiki/filter/date.md",
"content": "# `date`\nThe `date` filter formats a date in a variety of formats. It can handle old-school `java.util.Date`,\nJava 8 `java.time` constructs like `OffsetDateTime` and timestamps in milliseconds from the epoch.\nThe filter will construct a `java.text.SimpleDateFormat` or `java.time.format.DateTimeFormatter` using the provided\npattern and then use this newly created format to format the provided date object. If you don't provide a pattern,\neither `DateTimeFormatter.ISO_DATE_TIME` or `yyyy-MM-dd'T'HH:mm:ssZ` will be used.\n\n```twig\n{{ user.birthday | date(\"yyyy-MM-dd\") }}\n```\n\nAn alternative way to use this filter is to use it on a string but then provide two arguments:\nthe first is the desired pattern for the output, and the second is the existing format used to parse the\ninput string into a `java.util.Date` object.\n```twig\n{{ \"July 24, 2001\" | date(\"yyyy-MM-dd\", existingFormat=\"MMMM dd, yyyy\") }}\n```\nThe above example will output the following:\n```twig\n2001-07-24\n```\n\n## Time zones\n\nIf the provided date has time zone info (e.g. `OffsetDateTime`) then it will be used. If the provided date has no\ntime zone info, by default the system time zone will be used. If you need to use a specific\ntime zone then you can pass in a `timeZone` parameter any string that's understood by `ZoneId` / `ZoneInfo`:\n```twig\n{# the timeZone parameter will be ignored #}\n{{ someOffsetDateTime | date(\"yyyy-MM-dd'T'HH:mm:ssX\", timeZone=\"UTC\") }}\n{# the provided time zone will override the system default #}\n{{ someInstant | date(\"yyyy-MM-dd'T'HH:mm:ssX\", timeZone=\"Pacific/Funafuti\") }}\n```\n\n## Arguments\n- format\n- existingFormat\n- timeZone\n"
},
{
"path": "docs/src/orchid/resources/wiki/filter/default.md",
"content": "## `default`\nThe `default` filter will render a default value if and only if the object being filtered is empty.\nA variable is empty if it is null, an empty string, an empty collection, or an empty map.\n```twig\n{{ user.phoneNumber | default(\"No phone number\") }}\n```\nIn the following example, if `foo`, `bar`, or `baz` are null the output will become an empty string which is a perfect use case for the default filter:\n```twig\n{{ foo.bar.baz | default(\"No baz\") }}\n```\nNote that the default filter will suppress any `AttributeNotFoundException` exceptions that will usually be thrown when `strictVariables` is set to `true`.\n\n## Arguments\n- default\n"
},
{
"path": "docs/src/orchid/resources/wiki/filter/escape.md",
"content": "---\n---\n\n# `escape`\nThe `escape` filter will turn special characters into safe character references in order to avoid XSS\nvulnerabilities. This filter will typically only need to be used if you've turned off autoescaping.\n```twig\n{% verbatim %}\n{{ \"
\" | escape }}\n{# output: <div> #}\n{% endverbatim %}\n```\nPlease read the {{ anchor('escaping guide', 'Escaping') }} for more information about escaping.\n\n## Arguments\n- strategy"
},
{
"path": "docs/src/orchid/resources/wiki/filter/first.md",
"content": "# `first`\nThe `first` filter will return the first item of a collection, or the first letter of a string.\n```twig\n{{ users | first }}\n{# will output the first item in the collection named 'users' #}\n\n{{ 'Mitch' | first }}\n{# will output 'M' #}\n```"
},
{
"path": "docs/src/orchid/resources/wiki/filter/format.md",
"content": "# `format`\nThe `format` filter formats a string by replacing placeholders with the provided arguments (placeholders follows the `String.format` notation).\n```twig\n{{ 'Hello %s!' | format('World') }}\n{# Hello World! #}\n```"
},
{
"path": "docs/src/orchid/resources/wiki/filter/join.md",
"content": "# `join`\nThe `join` filter will concatenate all items of a collection into a string. An optional argument can be given\nto be used as the separator between items.\n```twig\n{#\n List names = new ArrayList<>();\n names.add(\"Alex\");\n names.add(\"Joe\");\n names.add(\"Bob\");\n#}\n{{ names | join(',') }}\n{# will output: Alex,Joe,Bob #}\n```\n\n## Arguments\n- separator"
},
{
"path": "docs/src/orchid/resources/wiki/filter/last.md",
"content": "# `last`\nThe `last` filter will return the last item of a collection, or the last letter of a string.\n```twig\n{{ users | last }}\n{# will output the last item in the collection named 'users' #}\n\n{{ 'Mitch' | last }}\n{# will output 'h' #}\n```"
},
{
"path": "docs/src/orchid/resources/wiki/filter/length.md",
"content": "# `length`\nThe `length` filter returns the number of items of collection, map or the length of a string:\n\n```twig\n{% if users|length > 10 %}\n ...\n{% endif %}\n```\n"
},
{
"path": "docs/src/orchid/resources/wiki/filter/lower.md",
"content": "# `lower`\nThe `lower` filter makes an entire string lower case.\n```twig\n{{ \"THIS IS A LOUD SENTENCE\" | lower }}\n```\nThe above example will output the following:\n```twig\nthis is a loud sentence\n```"
},
{
"path": "docs/src/orchid/resources/wiki/filter/nl2br.md",
"content": "# `nl2br`\n\nThe `nl2br` filter converts newline characters (`\\r`, `\\n`, `\\r\\n`) in a string to HTML line break tags (` `). This\nis useful when you want to preserve line breaks in text when displaying it in a web page.\n\n```pebble\n{{ \"I like Pebble.\\nYou will like it too.\"|nl2br }}\n{# outputs\n I like Pebble. You will like it too.\n#}\n```\n"
},
{
"path": "docs/src/orchid/resources/wiki/filter/numberformat.md",
"content": "# `numberformat`\nThe `numberformat` filter is used to format a decimal number. Behind the scenes it uses `java.text.DecimalFormat`.\n```twig\n{{ 3.141592653 | numberformat(\"#.##\") }}\n```\nThe above example will output the following:\n```twig\n3.14\n```\n\n## Arguments\n- format"
},
{
"path": "docs/src/orchid/resources/wiki/filter/raw.md",
"content": "---\n---\n\n# `raw`\nThe `raw` filter prevents the output of an expression from being escaped by the autoescaper.\nThe `raw` filter must be the very last operation performed within the expression otherwise the\nautoescaper will deem the expression as potentially unsafe and escape it regardless.\n\n```twig\n{% verbatim %}\n{% set danger = \"
\" %}\n{{ danger | upper | raw }}\n{# ouptut:
#}\n{% endverbatim %}\n```\n\nIf the `raw` filter is not the last operation performed then the expression will be escaped:\n```twig\n{% verbatim %}\n{% set danger = \"
\" %}\n{{ danger | raw | upper }}\n{# output: <DIV> #}\n{% endverbatim %}\n```\nPlease read the {{ anchor('escaping guide', 'Escaping') }} for more information about escaping."
},
{
"path": "docs/src/orchid/resources/wiki/filter/replace.md",
"content": "# `replace`\nThe 'replace' filter formats a given string by replacing the placeholders (placeholders are free-form):\n```twig\n{{ \"I like %this% and %that%.\" | replace({'%this%': foo, '%that%': \"bar\"}) }}\n```\n\n## Arguments\n- placeholders to replace"
},
{
"path": "docs/src/orchid/resources/wiki/filter/reverse.md",
"content": "# `reverse`\nThe 'reverse' filter reverses a List:\n```twig\n{% for user in users | reverse %} {{ user }} {% endfor %}\n```"
},
{
"path": "docs/src/orchid/resources/wiki/filter/rsort.md",
"content": "# `rsort`\nThe `rsort` filter will sort a list in reversed order. The items of the list must implement `Comparable`.\n```twig\n{% for user in users | rsort %}\n\t{{ user.name }}\n{% endfor %}\n```"
},
{
"path": "docs/src/orchid/resources/wiki/filter/sha256.md",
"content": "---\n---\n\n# `sha256`\nThe `sha256` filter returns the SHA-256 hash of the given UTF-8 String.\n\n```twig\n{% verbatim %}{{ \"test\" | sha256 }}{% endverbatim %}\n```\nThe above example will output the following:\n```\n9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08\n```"
},
{
"path": "docs/src/orchid/resources/wiki/filter/slice.md",
"content": "# `slice`\nThe `slice` filter returns a portion of a list, array, or string.\n```twig\n{{ ['apple', 'peach', 'pear', 'banana'] | slice(1,3) }}\n{# results in: [peach, pear] #}\n\n\n{{ 'Mitchell' | slice(1,3) }}\n{# results in: 'it' #}\n```\n\n## Arguments\n- `fromIndex`: 0-based and inclusive\n- `toIndex`: 0-based and exclusive\n"
},
{
"path": "docs/src/orchid/resources/wiki/filter/sort.md",
"content": "# `sort`\nThe `sort` filter will sort a list. The items of the list must implement `Comparable`.\n```twig\n{% for user in users | sort %}\n\t{{ user.name }}\n{% endfor %}\n```"
},
{
"path": "docs/src/orchid/resources/wiki/filter/split.md",
"content": "# `split`\nThe `split` filter splits a string by the given delimiter and returns a list of strings.\n```twig\n{% set foo = \"one,two,three\" | split(',') %}\n{# foo contains ['one', 'two', 'three'] #}\n```\n\nYou can also pass a limit argument:\n- If `limit` is positive, then the pattern will be applied at most n - 1 times, the array's length will be no greater than n, and the array's last entry will contain all input beyond the last matched delimiter;\n- If `limit` is negative, then the pattern will be applied as many times as possible and the array can have any length;\n- If `limit` is zero, then the pattern will be applied as many times as possible, the array can have any length, and trailing empty strings will be discarded;\n\n```twig\n{% set foo = \"one,two,three,four,five\" | split(',', 3) %}\n{# foo contains ['one', 'two', 'three,four,five'] #}\n```\n\n## Arguments\n- delimiter: The delimiter\n- limit: The limit argument"
},
{
"path": "docs/src/orchid/resources/wiki/filter/title.md",
"content": "---\n---\n\n# `title`\nThe `title` filter will capitalize the first letter of each word.\n```twig\n{% verbatim %}\n{{ \"article title\" | title }}\n{% endverbatim %}\n```\nThe above example will output the following:\n```twig\nArticle Title\n```\n\nSee also: {{ anchor('capitalize') }}\n"
},
{
"path": "docs/src/orchid/resources/wiki/filter/trim.md",
"content": "# `trim`\nThe `trim` filter is used to trim whitespace off the beginning and end of a string.\n```twig\n{{ \" This text has too much whitespace. \" | trim }}\n```\nThe above example will output the following:\n```twig\nThis text has too much whitespace.\n```"
},
{
"path": "docs/src/orchid/resources/wiki/filter/upper.md",
"content": "# `upper`\nThe `upper` filter makes an entire string upper case.\n\n```twig\n{{ \"this is a quiet sentence.\" | upper }}\n```\nThe above example will output the following:\n```twig\nTHIS IS A QUIET SENTENCE.\n```"
},
{
"path": "docs/src/orchid/resources/wiki/filter/urlencode.md",
"content": "# `urlencode`\n\nThe `urlencod` translates a string into `application/x-www-form-urlencoded` format using the \"UTF-8\" encoding scheme.\n\n```twig\n{{ \"The string ĂŒ@foo-bar\" | urlencode }}\n```\n\nThe above example will output the following:\n```twig\nThe+string+%C3%BC%40foo-bar\n```"
},
{
"path": "docs/src/orchid/resources/wiki/function/blockFunction.md",
"content": "---\n---\n\n# `block`\nThe `block` function is used to render the contents of a block more than once. It is not to be confused\nwith the block *tag* which is used to declare blocks.\n\nThe following example will render the contents of the \"post\" block twice; once where it was declared\nand again using the `block` function:\n```twig\n{% verbatim %}\n{% block \"post\" %} content {% endblock %}\n\n{{ block(\"post\") }}\n{% endverbatim %}\n```\nThe above example will output the following:\n```twig\ncontent\n\ncontent\n```\n\n## Performance Warning\nThe `block` function will impair the use of the {{ anchor('flush') }} tag used within the block being rendered.\nIt is typically okay for a block to use the `flush` tag which will flush the already-rendered\ncontent to the user-provided `Writer` but the block function will internally use it's own `StringWriter` and\ntherefore flushing inside the block will no longer do any good (nor will it do harm)."
},
{
"path": "docs/src/orchid/resources/wiki/function/i18n.md",
"content": "# `i18n`\nThe `i18n` function is used to retrieve messages from a locale-specific `ResourceBundle`.\nEvery `PebbleTemplate` is assigned a default locale from the `PebbleEngine`. At the point of evaluation, this\nlocale can be changed with an argument to the `evaluate(...)` method of the individual template.\n\nThe `i18n` function wraps around `ResourceBundle.getBundle(name, locale).getObject(key)`.\nThe first argument to the `i18n` function is the name of the bundle and the second argument is the key\nwithin the bundle.\n\n```twig\n{{ i18n(\"messages\",\"greeting\") }}\n```\n\nThe above example assumes you have `messages.properties` on your classpath and that that file contains\na key by the name of `greeting`. If the locale of that template was `es_US` for example, it would look for a\n`message_es_US.properties` file instead.\n\nGoing a little further, you can use variables within your message and pass a list of params to this\nfunction which will replace your variables using `MessageFormat`:\n```twig\n{# greeting.someone=Hello, {0} #}\n{{ i18n(\"messages\",\"greeting\", \"Jacob\") }}\n\n{# output: Hello, Jacob #}\n```\n\n## Arguments\n- bundle\n- key\n- params"
},
{
"path": "docs/src/orchid/resources/wiki/function/max.md",
"content": "# `max`\nThe `max` function will return the largest of it's numerical arguments.\n```twig\n{{ max(user.age, 80) }}\n```"
},
{
"path": "docs/src/orchid/resources/wiki/function/min.md",
"content": "# `min`\nThe `min` function will return the smallest of it's numerical arguments.\n```twig\n{{ min(user.age, 80) }}\n```"
},
{
"path": "docs/src/orchid/resources/wiki/function/parent.md",
"content": "# `parent`\n\nThe `parent` function is used inside of a block to render the content that the parent template would\nhave rendered inside of the block had the current template not overriden it. It is similar to Java's `super` keyword.\n\nLet's assume you have a template, \"parent.peb\" that looks something like this:\n```twig\n{% block \"content\" %}\n\tparent contents\n{% endblock %}\n```\nAnd then you have another template, \"child.peb\" that extends \"parent.peb\":\n```twig\n{% extends \"parent.peb\" %}\n\n{% block \"content\" %}\n\tchild contents\n\t{{ parent() }}\n{% endblock %}\n```\nThe output will look something like the following:\n```twig\nparent contents\nchild contents\n```"
},
{
"path": "docs/src/orchid/resources/wiki/function/range.md",
"content": "# `range`\nThe `range` function will return a list containing an arithmetic progression of numbers:\n```twig\n{% for i in range(0, 3) %}\n {{ i }},\n{% endfor %}\n\n{# outputs 0, 1, 2, 3, #}\n```\n\nWhen step is given (as the third parameter), it specifies the increment (or decrement):\n```twig\n{% for i in range(0, 6, 2) %}\n {{ i }},\n{% endfor %}\n\n{# outputs 0, 2, 4, 6, #}\n```\n\nPebble built-in .. operator is just a shortcut for the range function with a step of 1+\n```twig\n{% for i in 0..3 %}\n {{ i }},\n{% endfor %}\n\n{# outputs 0, 1, 2, 3, #}\n```\n"
},
{
"path": "docs/src/orchid/resources/wiki/guide/basic-usage.md",
"content": "---\n---\n\n# Basic Usage\n\n## Introduction\nPebble templates can be used to generate any sort of textual output. It is typically used to generate HTML but it can\nalso be used to create CSS, XML, JS, etc. A template itself will contain whatever language you are attempting to output\nalongside Pebble-specific features and syntax. Here is a simple example that will generate a trivial HTML page:\n\n```twig\n{% verbatim %}\n\n\t\n\t\t{{ websiteTitle }}\n\t\n\t\n\t\t{{ content }}\n\t\n\n{%- endverbatim %}\n```\nWhen you evaluate the template you will provide it with a \"context\" which is just a map of variables.\nThis context should include the two variables above, `websiteTitle` and `content`.\n\n## Set Up\nYou will want to begin by creating a PebbleEngine object which is responsible for compiling your templates:\n```java\nPebbleEngine engine = new PebbleEngine.Builder().build();\n```\nAnd now, with your new PebbleEngine instance you can start compiling templates:\n```java\nPebbleTemplate compiledTemplate = engine.getTemplate(\"templates/home.html\");\n```\nFinally, simply provide your compiled template with a java.io.Writer object and a Map of variables (the context)\nto get your output!\n```java\nWriter writer = new StringWriter();\n\nMap context = new HashMap<>();\ncontext.put(\"websiteTitle\", \"My First Website\");\ncontext.put(\"content\", \"My Interesting Content\");\n\ncompiledTemplate.evaluate(writer, context);\n\nString output = writer.toString();\n```\n\n## Syntax Reference\nThere are two primary delimiters used within a Pebble template: `{% verbatim %}{{ ... }}{% endverbatim %}` and `{% verbatim %}{% ... %}{% endverbatim %}`. The first set of delimiters\nwill output the result of an expression. Expressions can be very simple (ex. a variable name) or much more complex.\nThe second set of delimiters is used to change the control flow of the template; it can contain an if-statement,\ndefine a parent template, define a new block, etc.\n\n## Variables\nYou can print variables directly to the output; for example, if the context contains a variable called `foo` which is a\nString with the value \"bar\" you can do the following which will output \"bar\".\n```twig\n{% verbatim %}{{ foo }}{% endverbatim %}\n```\nYou can use the dot (.) notation to access attributes of variables. If the attribute contains any atypical\ncharacters, you can use the subscript notation ([]) instead.\n```twig\n{% verbatim %}\n{{ foo.bar }}\n{{ foo[\"bar\"] }}\n{%- endverbatim %}\n```\nBehind the scenes `foo.bar` will attempt the following techniques to to access the `bar` attribute of the `foo`\nvariable:\n- If `foo` is a Map, `foo.get(\"bar\")`\n- `foo.getBar()`\n- `foo.isBar()`\n- `foo.hasBar()`\n- `foo.bar()`\n- `foo.bar`\n\nAdditionally, if `foo` is a List, then `foo[0]` can be used instead of `foo.get(0)`.\n\nIf the value of variable (or attribute) is null it will output an empty string.\n\n## Type Safety\nPebble templates are dynamically typed and any possible type safety issues won't occur until the actual runtime\nevaluation of your templates. Pebble does however allow you to choose how to handle type safety issues with the use\nof it's `strictVariables` setting. By default, `strictVariables` is set to `false` which means that the following:\n```twig\n{% verbatim %}{{ foo.bar }}{% endverbatim %}\n```\nwill print an empty string even if the object `foo` does not actually have an attribute called `bar`.\nIf `strictVariables` is set to true, the above expression would throw an exception.\n\nWhen `strictVariables` is set to false your expressions are also null safe. The following expression will print an\nempty string even if foo and/or bar are null:\n```twig\n{% verbatim %}{{ foo.bar.baz }}{% endverbatim %}\n```\nThe {{ anchor('default') }} filter might come in handy for the above situations.\n\n## Filters\n\nOutput can be further modified with the use of filters. Filters are separated from the variable using a\npipe symbol (`|`) and may have optional arguments in parentheses. Multiple filters can be chained and the output\nof one filter is applied to the next.\n```twig\n{% verbatim %}{{ \"If life gives you lemons, eat lemons.\" | upper | abbreviate(13) }}{% endverbatim %}\n```\nThe above example will output the following:\n```twig\nIF LIFE GI...\n```\n\n## Functions\nWhereas filters are intended to modify existing content/variables, functions are intended to generate new content.\nSimilar to other programming languages, functions are invoked via their name followed by parentheses (`()`).\n```twig\n{% verbatim %}{{ max(user.score, highscore) }}{% endverbatim %}\n```\n\n## Control Structure\nPebble provides several tags to control the flow of your template, two of the main ones being the {{ anchor('for') }} loop,\nand {{ anchor('if') }} statements.\n```twig\n{% verbatim %}\n{% for article in articles %}\n
\n{% endif %}\n{%- endverbatim %}\n```\n\n## Including other Templates\nThe {{ anchor('include') }} tag is used to include the rendered output of one template into another.\n```twig\n{% verbatim %}\n
\n\t{% include \"advertisement.html\" %}\n
\n{%- endverbatim %}\n```\n\n## Template Inheritance\nTemplate inheritance is the most powerful feature of Pebble. It allows templates to override sections of their parent\ntemplate. In your parent template you define \"blocks\" which are the sections that are allowed to be overriden.\n\nFirst let us look at an example of a parent template:\n```twig\n{% verbatim %}\n\n\n\t{% block title %}My Website{% endblock %}\n\n\n\t
\n\t\t{% block content %}{% endblock %}\n\t
\n\t\n\n\n{% endverbatim %}\n```\nIn the above example, we have used the {{ anchor('block') }} tag to define several sections that child templates are\nallowed to override.\n\nA child template might look like this:\n\n```twig\n{% verbatim %}\n{% extends \"parent.html\" %}\n\n{% block title %} Home {% endblock %}\n\n{% block content %}\n\t
Home
\n\t
Welcome to my home page.
\n{% endblock %}\n{%- endverbatim %}\n```\n\nThe first line uses the {{ anchor('extends') }} tag to declare the parent template. The extends tag should be the\nfirst tag in the template and there can only be one.\n\nEvaluating the child template will produce the following output:\n\n```twig\n\n\n\tHome\n\n\n\t
\n\t\t
Home
\n\t\t
Welcome to my home page.
\n\t
\n\t\n\n\n```\n\nYou may have noticed that in the above example, because the child template doesn't override the `footer` block,\nthe value from the parent is used instead.\n\nDynamic inheritance is possible by using an expression with the `extends` tag:\n```twig\n{% verbatim %}{% extends ajax ? 'ajax.html' : 'base.html' %}{% endverbatim %}\n```\n\n## Macros\nMacros are lightweight and reusable template fragments. A macro is defined via the {{ anchor('macro') }} tag:\n```twig\n{% verbatim %}\n{% macro input(type, name) %}\n\t\n{% endmacro %}\n{% endverbatim %}\n```\nAnd the macro will be invoked just like a function:\n```twig\n{% verbatim %}{{ input(\"text\", \"name\", \"Mitchell\") }}{% endverbatim %}\n```\nChild templates will have access to macros defined in a parent template. To use macros located in a completely\ndifferent template, you can use the {{ anchor('import') }}) tag. A macro does not have access to the main context; the\nonly variables it can access are it's local arguments.\n\n## Named Arguments\nUsing named arguments allows you to be more explicit with the values you are passing to a filter, function, test or\nmacro. They also allow you to avoid specifying arguments for which you don't want to change the default value.\n```twig\n{% verbatim %}{{ stringDate | date(existingFormat=\"yyyy-MMMM-d\", format=\"yyyy/MMMM/d\") }}{% endverbatim %}\n```\n\nPositional arguments can be used in conjunction with named arguments but all positional arguments must come before\nany named arguments:\n```twig\n{% verbatim %}{{ stringDate | date(\"yyyy/MMMM/d\", existingFormat=\"yyyy-MMMM-d\") }}{% endverbatim %}\n```\nMacros are a great use case for named arguments because they also allow you to define default values for\nunused arguments:\n```twig\n{% verbatim %}\n{% macro input(type=\"text\", name, value) %}\n\t\n{% endmacro %}\n\n{{ input(name=\"country\") }}\n\n{# will output: #}\n{%- endverbatim %}\n```\n\n## Escaping\n[XSS vulnerabilites](https://en.wikipedia.org/wiki/Cross-site_scripting) are the most common types of security\nvulnerabilities in web applications and in order to avoid them you must escape potentially unsafe data before\npresenting it to the end user. Pebble provides autoescaping of all such data which is enabled by default.\nAutoescaping can be turned off, in which case Pebble provides an escape filter for more fine-grained manual escaping.\n\nThe following is an example of how autoescaping will escape your context variables:\n```twig\n{% verbatim %}\n{% set danger = \" \" %}\n{{ danger }}\n\n{# will output: <br> #}\n{%- endverbatim %}\n```\nIf autoescaping is disabled you can still use the {{ anchor('escape') }} filter to aid with manual escaping:\n```twig\n{% verbatim %}\n{% set danger = \" \" %}\n{{ danger | escape }}\n\n{# will output: <br> #}\n{%- endverbatim %}\n```\nBy default, the autoescaping mechanism and the escape filter assume that it is escaping within an HTML context.\nYou may want to use an alternate escaping strategy depending on the context:\n```twig\n{% verbatim %}\n{% set danger = \"alert(...)\" %}\n\n{%- endverbatim %}\n```\nSee the {{ anchor('escaping guide', 'Escaping') }} for more information on how autoescaping works, how to disable it, and the various\nescaping strategies that are available.\n\n## Whitespace\nThe first newline after a pebble tag is automatically ignored; all other whitespace is ignored by Pebble and will be\nincluded in the rendered output.\n\nPebble provides a whitespace control modifier to trim leading or trailing whitespace adjacent to any pebble tag.\n```twig\n{% verbatim %}\n
\t\t{{- \"no whitespace\" -}}\t\t
\n{# output: \"
no whitespace
\" #}\n{%- endverbatim %}\n```\nIt is also possible to only use the modifier on one side of the tag:\n```twig\n{% verbatim %}\n
\t\t{{- \"no leading whitespace\" }}\t\t
\n{# output: \"
no whitespace\t\t
\" #}\n{%- endverbatim %}\n```\n\n## Comments\nYou can comment out any part of the template using the `{# ... #}` delimiters. These comments will not appear in\nthe rendered output.\n```twig\n{% verbatim %}\n{# THIS IS A COMMENT #}\n{% for article in articles %}\n\t
{{ article.title }}
\n\t
{{ article.content }}
\n{% endfor %}\n{%- endverbatim %}\n```\n\n## Expressions\nExpressions in a Pebble template are very similar to expressions found in Java.\n\n### Literals\nThe simplest form of expressions are literals. Literals are representations for Java types such as strings and numbers.\n- `\"Hello World\"`: Everything between two double or single quotes is a string. You can use a backslash to escape\nquotation marks within the string.\n- `\"Hello #{who}\"`: String interpolation is also possible using `#{}` inside quotes. In this example,\nif the value of the variable `who` is `\"world\"`, then the expression will be evaluated to `\"Hello world\"`.\n- `100 + 10l * 2.5`: Integers, longs and floating point numbers are similar to their Java counterparts.\n- `true` / `false`: Boolean values equivalent to their Java counterparts.\n- `null`: Represents no specific value, similar to it's Java counterpart. `none` is an alias for null.\n\n### Collections\nBoth lists and maps can be created directly within the template.\n- `[\"apple\", \"banana\", \"pear\"]`: A list of strings\n- `{\"apple\":\"red\", \"banana\":\"yellow\", \"pear\":\"green\"}`: A map of strings\n\nThe collections can contain expressions.\n\n### Math\nPebble allows you to calculate values using some basic mathematical operators. The following operators are supported:\n- `+`: Addition\n- `-`: Subtraction\n- `/`: Division\n- `%`: Modulus\n- `*`: Multiplication\n\n### Logic\nYou can combine multiple expressions with the following operators:\n- `and`: Returns true if both operands are true\n- `or`: Returns true if either operand is true\n- `not`: Negates an expression\n- `(...)`: Groups expressions together\n\n### Comparisons\nThe following comparison operators are supported in any expression: `==`, `!=`, `<`, `>`, `>=`, and `<=`.\n```twig\n{% verbatim %}\n{% if user.age >= 18 %}\n\t...\n{% endif %}\n{%- endverbatim %}\n```\n\n### Tests\nThe `is` operator performs tests. Tests can be used to test an expression for certain qualities.\nThe right operand is the name of the test:\n```twig\n{% verbatim %}\n{% if 3 is odd %}\n\t...\n{% endif %}\n{%- endverbatim %}\n```\nTests can be negated by using the is not operator:\n```twig\n{% verbatim %}\n{% if name is not null %}\n\t...\n{% endif %}\n{%- endverbatim %}\n```\n\n### Conditional (Ternary) Operator\nThe conditional operator is similar to its Java counterpart:\n```twig\n{% verbatim %}{{ foo ? \"yes\" : \"no\" }}{% endverbatim %}\n```\n\n### Operator Precedence\nIn order from highest to lowest precedence:\n- `.`\n- `|`\n- `%`, `/`, `*`\n- `-`, `+`\n- `==`, `!=`, `>`, `<`, `>=`, `<=`\n- `is`, `is not`\n- `and`\n- `or`\n\n### Limiting the size of the rendered output\n\nIn case youâre running Pebble with templates provided by someone else, thereâs an attack similar to\n[zip bombs](https://en.wikipedia.org/wiki/Zip_bomb) or [XML bombs](https://en.wikipedia.org/wiki/Billion_laughs_attack)\nthat might cause your process to run out of memory. To protect against it, you can limit the size of the output when\nevaluating a template:\n```java\nPebbleEngine pebble = new PebbleEngine.Builder()\n // Output should not exceed 10 MB.\n .maxRenderedSize(10 * 1024 * 1024)\n .build();\n```\n\nThis will throw a `PebbleException` when a template evaluation tries to write more characters than the limit you set.\n\n### IDE's plugin\nIf you want to add IDE's syntax highlighting, you can install this [plugin](https://plugins.jetbrains.com/idea/plugin/9407-pebble) for IntelliJ. Thank you to Bastien Jansen for his contribution.\n"
},
{
"path": "docs/src/orchid/resources/wiki/guide/customize-defaults.md",
"content": "---\n---\n\nPebble comes with a rich set of built-in tags and filters that will help you render your templates into websites and other documents with ease. However, imagine a more specific use-case where the templates are not entirely under your control.\n\nIn these cases it might be advised to consider stripping-down Pebbles' built-in functionality that may otherwise introduce security-concers regarding the integrity and stability of your application.\n\n### Opt-Out using ExtensionCustomizer\n\nThe `ExtensionCustomizer` base class can be used to gain access to the default functionality before it is loaded into Pebbles template engine. Overwrite methods to get hold on provided default-functionality and modify whatever should be available for the template engine.\n\nThe following example removes the `ForTokenParser`, i.e. the ability to parse `{% for %}{{ ... }}{% endfor %}` constructs:\n\n```java\nclass ExampleOptOuts extends ExtensionCustomizer {\n\n public ExampleOptOuts(Extension ext) {\n super(ext);\n }\n\n @Override\n public List getTokenParsers() {\n List tokenParsers = Optional.ofNullable(super.getTokenParsers())\n .map(ArrayList::new).orElseGet(ArrayList::new);\n \n tokenParsers.removeIf(x -> x instanceof ForTokenParser);\n return tokenParsers;\n }\n\n}\n```\n\nThe `ExtensionCustomizer` will be used to wrap any Pebble-extension which is provided by default. It can be registered in your setup code to create `PebbleEngine`:\n\n```java\nPebbleEngine engine = new PebbleEngine.Builder().registerExtensionCustomizer(ExampleOptOuts::new).build();\n```\n\n### Default implementation of ExtensionCustomizer\n\nThe `DisallowExtensionCustomizerBuilder` class can be used to disallow some default functionality, make pebble more controllable.\n\nFor example of use, see below:\n\n```java\nPebbleEngine engine = new PebbleEngine.Builder()\n .registerExtensionCustomizer(new DisallowExtensionCustomizerBuilder()\n .disallowedTokenParserTags(singletonList(\"flush\"))\n .disallowedFunctionKeys(singletonList(\"max\"))\n .disallowedFilterKeys(singletonList(\"upper\"))\n .disallowedTestKeys(singletonList(\"null\"))\n .disallowedBinaryOperatorSymbols(singletonList(\">\"))\n .disallowedUnaryOperatorSymbols(singletonList(\"-\"))\n .build())\n .build();\n```"
},
{
"path": "docs/src/orchid/resources/wiki/guide/escaping.md",
"content": "---\n---\n\n# Escaping\n\n## Overview\n[XSS vulnerabilites](https://en.wikipedia.org/wiki/Cross-site_scripting) are the most common types of security\nvulnerabilities in web applications and in order to avoid them you must escape potentially unsafe data before\npresenting it to the end user. Pebble provides autoescaping of all such data which is enabled by default.\nAutoescaping can be turned off, in which case Pebble provides an {{ anchor('escape') }} filter for more\nfine-grained manual escaping.\n\n## Autoescaping\nAutoescaping, which is enabled by default, will automatically escape the outcome of expressions\ncontained within print delimiters, i.e. {% verbatim %}`{{` and `}}`{% endverbatim %}:\n```twig\n{% verbatim %}\n{% set danger = \" \" %}\n{{ danger }}\n\n{# will output: <br> #}\n{%- endverbatim %}\n```\nThe {{ anchor('raw') }} filter can be used to prevent the autoescaper from escaping a particular expression. It is\nimportant that the raw filter is the last operation performed in the expression.\n```twig\n{% verbatim %}\n{% set danger = \" \" %}\n{{ danger | raw }}\n\n{# will output: #}\n{%- endverbatim %}\n```\nIf the raw filter is not the last operation performed within the expression, the expression will be deemed\nas possibly unsafe by the autoescaper and will be escaped. For example:\n```twig\n{% verbatim %}\n{% set danger = \" \" %}\n{{ danger | raw | uppercase }}\n\n{# will output: <BR> #}\n{%- endverbatim %}\n```\n\n### Exceptions\nThere are a few exceptions where expressions are **not** automatically escaped:\n- If the expression only contains a string literal, it is assumed to be safe. For example:\n```twig\n{% verbatim %}\n{{ ' ' }}\n\n{# will output: #}\n{%- endverbatim %}\n```\n- The last operation contained within that expression is a filter or function that explicitly returns safe output. Such a filter or function would return an instance of `SafeString` instead of a regular String. The built-in filters that return safe markup include: `date`, `escape`, and `raw`. These filters must be the last operation performed within the expression in order for their output to be ignored by the autoescaper. For example:\n```twig\n{% verbatim %}\n{% set danger = \" \" %}\n{{ danger | uppercase | raw }}\n\n{# will output: #}\n{%- endverbatim %}\n```\n\n### Autoescape Tag\nThe {{ anchor('autoescape') }} tag can be used to temporarily disable/re-enable the autoescaper as well as\nchange the escaping strategy for a portion of the template.\n```twig\n{% verbatim %}\n{{ danger }} {# will be escaped by default #}\n{% autoescape false %}\n\t{{ danger }} {# will not be escaped #}\n{% endautoescape %}\n{%- endverbatim %}\n```\n```twig\n{% verbatim %}\n{{ danger }} {# will use the \"html\" escaping strategy #}\n{% autoescape \"js\" %}\n\t{{ danger }} {# will use the \"js\" escaping strategy #}\n{% endautoescape %}\n{%- endverbatim %}\n```\n\n### Disabling Autoescaper\n```java\nPebbleEngine engine = new PebbleEngine.Builder().autoEscaping(false).build();\n```\n\n## Manual Escaping\nIf autoescaping is disabled you can still use the {{ anchor('escape') }} filter to aid with manual escaping:\n```twig\n{% verbatim %}\n{% set danger = \" \" %}\n{{ danger | escape }}\n\n{# will output: <br> #}\n{%- endverbatim %}\n```\n\n## Strategies\nWhen escaping data it is crucial that you utilize the correct escaping strategy depending on the context of the data.\nBy default, the autoescaper and the `escape` filter assume that you are escaping HTML data.\nI highly recommend reading the [OWASP Cheat Sheet](https://www.owasp.org/index.php/XSS_(Cross_Site_Scripting)_Prevention_Cheat_Sheet)\nto understand the significance of escaping context.\n\nPebble provides the following escaping strategies:\n\n- html\n- js\n- css\n- url_param\n\nYou can use the {{ anchor('autoescape') }} tag to temporarily change the strategy used by the autoescaper otherwise you can\nchange the globally used default strategy:\n```java\nPebbleEngine engine = new PebbleEngine.Builder().defaultEscapingStrategy(\"js\").build();\n```\nThe escape filter will also accept a strategy as an argument:\n```js\n{% verbatim %}\nvar username =\"{{ user.name | escape(strategy=\"js\") }}\";\n{%- endverbatim %}\n```\n\n### Custom Strategy\nYou can add a custom escaping strategy by implementing `EscapingStrategy` and adding it to the `EscaperExtension`:\n```java\nPebbleEngine engine = new PebbleEngine.Builder().addEscapingStrategy(\"custom\", new CustomEscapingStrategy()).build();\n```"
},
{
"path": "docs/src/orchid/resources/wiki/guide/extending-pebble.md",
"content": "---\n---\n\n# Extending Pebble\n\n## Overview\nPebble was designed to be flexible and accomodate the requirements of any project. You can add your own tags,\nfunctions, operators, filters, tests, and global variables. The majority of these are quite trivial to implement.\n\nBegin by creating a class that implements `Extension`. For your own convenience, I recommend extending\n`AbstractExtension` if you can. After implementing the required methods, register your extension with the `PebbleEngine`\nbefore compiling any templates:\n```java\nPebbleEngine engine = new PebbleEngine.Builder().extension(new CustomExtension()).build();\n```\n\n## Filters\nTo create custom filters, implement the `getFilters()` method of your extension which will return a map of filter\nnames and their corresponding implementations. A filter implementation must implement the `Filter` interface.\nThe\t`Filter` interface requires two methods to be implemented, `getArgumentNames()` and `apply()`. The\n`getArgumentNames()` method returns a list of Strings that define both the order and names of expected arguments. If \nthis method returns null or an empty list, the filter supports dynamic arguments. This means the user can pass any \nnumber of argumentsâeither named (e.g., myFilter(param=\"value\")) or positional (e.g., myFilter(\"value\"))âand they will be available in the arguments map.\n\nThe `apply` method is the actual filter implementation. Here's the parameters definition.\n\n| Parameter name | Description |\n| --- | --- |\n| input | the data to be filtered |\n| args | the map of arguments the user may have provided |\n| self | An instance of `PebbleTemplate` which can be used to retrieve the template name for example |\n| context | An instance of `EvaluationContext` which can be used to retrieve the locale for example| \n| lineNumber | Useful when throwing exception to provide line number | \n \nBecause Pebble is dynamically typed, you will have to downcast the arguments to the expected type.\nHere is an example of how the {{ anchor('upper') }} filter might be implemented:\n```java\npublic class UpperFilter implements Filter {\n\n\t@Override\n\tpublic List getArgumentNames() {\n\t\treturn null;\n\t}\n\n\t@Override\n\tpublic Object apply(Object input, Map args, PebbleTemplate self, EvaluationContext context, int lineNumber){\n\t\tif(input == null){\n\t\t\treturn null;\n\t\t}\n\t\tif (input instanceof String) {\n\t\t\treturn ((String) input).toUpperCase(context.getLocale());\n\t\t} else {\n\t\t\treturn input.toString().toUpperCase(context.getLocale());\n\t\t}\n\t}\n\n}\n```\n\n## Tests\nAdding custom tests is very similar to custom filters. Implement the `getTests()` method within your\nextension which will return a map of test names and their corresponding implementations. A test\nimplementation will implement the `Test` interface. The `Test` interface is exactly like the `Filter`\ninterface except the apply method returns a boolean instead of an arbitrary object of any type.\n\nHere is an example of how the {{ anchor('even') }} test might be implemented:\n```java\npublic class EvenTest implements Test {\n\n\t@Override\n\tpublic List getArgumentNames() {\n\t\treturn null;\n\t}\n\n\t@Override\n\tpublic boolean apply(Object input, Map args, PebbleTemplate self, EvaluationContext context, int lineNumber){\n\t\tif (input == null) {\n\t\t\tthrow new PebbleException(null, \"Can not pass null value to \\\"even\\\" test.\", lineNumber, self.getName());\n\t\t}\n \n\t\tif (input instanceof Integer) {\n\t\t\treturn ((Integer) input) % 2 == 0;\n\t\t} else {\n\t\t\treturn ((Long) input) % 2 == 0;\n\t\t}\n\t}\n\n}\n```\n\n## Functions\nAdding functions is also very similar to custom filters. First and foremost, it's important to\nunderstand the different intentions behind a function and a filter because it can often be ambiguous\nwhich one should be implemented. A filter is intended to modify existing content where a function is\nmoreso intended to produce new content.\n\nTo add functions, implement the `getFunctions()` method within your extension which will return a map of function\nnames and their corresponding implementations. A function implementation will implement the `Function` interface.\nThe\t`Function` interface is very similar to the `Filter` and `Test` interfaces.\n\nHere is an example of how a fictional `fibonacciString` function might be implemented:\n```java\npublic class FibonnaciStringFunction implements Function {\n\n\t@Override\n\tpublic List getArgumentNames() {\n\t\tList names = new ArrayList<>();\n\t\tnames.add(\"length\");\n\t\treturn names;\n\t}\n\n\t@Override\n\tpublic Object execute(Map args, PebbleTemplate self, EvaluationContext context, int lineNumber) {\n\t\tInteger length = (Integer)args.get(\"length\");\n\t\tInteger prev1 = 0;\n\t\tInteger prev2 = 1;\n\n\t\tStringBuilder result = new StringBuilder();\n\n\t\tresult.append(\"01\");\n\n\t\tfor(int i = 2; i < length; i++){\n\t\t\tInteger next = prev1 + prev2;\n\t\t\tresult.append(next);\n\t\t\tprev1 = prev2;\n\t\t\tprev2 = next;\n\t\t}\n\t\treturn result.toString();\n\n\t}\n}\n```\n\n## Positional and Named Arguments\nFor filters, tests, and functions it is required that you implement the `getArgumentNames` method even if it\nreturns null. Returning a list of strings will allow the end user to call your filter/test/function using\nnamed arguments. If this method returns null or an empty list, the function supports dynamic arguments. This means \nthe user can pass any number of argumentsâeither named (e.g., myFunction(param=\"value\")) or positional \n(e.g., myFunction(\"value\"))âand they will be available in the arguments map.\n\nUsing the above fictional fibonacci function as an example, a user can invoke it in two different ways:\n```twig\n{% verbatim %}\n{{ fibonacci(10) }}\n{{ fibonacci(length=10) }}\n{%- endverbatim %}\n```\nIf the end user excludes the names and only uses positional arguments, the argument values will still end up\nbe mapped to the proper names when it's time to invoke the function's execute method. Your function implementation\ndoesn't have to worry whether the user used positional or named arguments. It is important though that if the\nfilter/function/test expects more than one argument, then the developer must communicate to the user the expected\norder of arguments in the chance that the user wants to invoke it without using names.\n\nSome functions such as the built in `min` and `max` functions accept an unlimited amount of arguments.\nFor this to happen, your function must not accept any named arguments (i.e. your `getArgumentNames` method\nwill return null or empty) and your `execute`` method will simply iterate over the values of the user provided\nargument map while ignoring the keys of that map (Pebble will use arbitrary keys if there are no names to map to).\n\n## Global Variables\nAdding global variables, which are variables that are accessbile to all templates, is very trivial.\nIn your custom extension, implement the `getGlobalVariables()` method which returns a `Map`.\nThe contents of this map will be merged into the context you provide to each template at the time of rendering.\n\n## Operators\nOperators are more complex to implement than filters or tests. To add custom operators, implement the\n`getBinaryOperators()` or the `getUnaryOperators()` method in your extension, or both. These methods return a\nlist of `BinaryOperator` or `UnaryOperator` objects, respectively.\n\nBinary operators require the following information:\n- Precedence: an integer relative to other operators which defines the order of operations.\n- Symbol: a String representing the actual operator. This is typically a single character but doesn't have to be.\n- Expression Class: A class that extends `BinaryExpression`. This class will perform the actual operator implementation.\n- Associativity: Either left or right depending on how the operator is used.\n\nA unary operator is much the same except it's expression class must extend `UnaryExpression` and there is no associativity.\n\nThe precedence values for existing core operators are as followed:\n- `or`: 10\n- `and`: 15\n- `is`: 20\n- `is not`: 20\n- `==`: 30\n- `!=`: 30\n- `>`: 30\n- `<`: 30\n- `>=`: 30\n- `<=`: 30\n- `+`: 40\n- `-`: 40\n- `not`: 50 (Unary)\n- `*`: 60\n- `/`: 60\n- `%`: 60\n- `|`: 100\n- `+`: 500 (Unary)\n- `-`: 500 (Unary)\n\nThe following is an\texample of how the addition operator (`+`) might have been implemented:\n```java\npublic class AdditionOperator implements BinaryOperator {\n\n\tpublic int getPrecedence(){\n\t\treturn 30;\n\t}\n\n\tpublic String getSymbol(){\n\t\treturn \"+\";\n\t}\n\n public BinaryExpression createInstance() {\n return new AddExpression();\n }\n\n public BinaryOperatorType getType() {\n return BinaryOperatorType.NORMAL;\n }\n\n\tpublic Associativity getAssociativity(){\n\t\treturn Associativity.LEFT;\n\t}\n\n}\n```\nAlongside each operator class you will also need to implement a corresponding `BinaryExpression` class\nwhich actually implements the operator. The above example references a fictional `AdditionExpression` class\nwhich might look like the following:\n```java\npublic class AdditionExpression extends BinaryExpression