Stencil

https://stencil.fuller.li/en/latest/
Admin
Stencil is a simple and powerful template language for Swift, offering a syntax similar to Django...
Tokens:10,585
Snippets:121
Trust Score:7.4
Update:1 year ago
Show doc for...
Tokens:
Raw
### Render a basic Stencil template directly

Source: https://stencil.fuller.li/en/latest/_sources/getting-started.rst

Demonstrates the simplest way to render a Stencil template. A Template instance is created from a string, and its render method is called with a context dictionary to produce the output.

```swift
let template = Template(templateString: "Hello {{ name }}")
try template.render(["name": "kyle"])
```

--------------------------------

### Load and render Stencil template from file system with FileSystemLoader

Source: https://stencil.fuller.li/en/latest/_sources/getting-started.rst

Shows how to load templates from disk using FileSystemLoader. An Environment is configured with the loader, pointing to a directory, and then a template is rendered by its name, enabling file-based template loading.

```swift
let fsLoader = FileSystemLoader(paths: ["templates/"])
let environment = Environment(loader: fsLoader)

let context = ["name": "kyle"]
try environment.renderTemplate(name: "index.html", context: context)
```

--------------------------------

### Render Stencil template using Environment

Source: https://stencil.fuller.li/en/latest/getting-started

For more advanced usage, this example shows how to render a template using an Environment object. An Environment provides more control and features, and its renderTemplate method is used here with a template string and context.

```Swift
let environment = Environment()

let context = ["name": "kyle"]
try environment.renderTemplate(string: "Hello {{ name }}", context: context)
```

--------------------------------

### Load and render Stencil template from file system

Source: https://stencil.fuller.li/en/latest/getting-started

This snippet illustrates how to use a FileSystemLoader to load templates from disk. It initializes the loader with a path, creates an Environment with this loader, and then renders a template by its name, 'index.html', from the specified directory.

```Swift
let fsLoader = FileSystemLoader(paths: ["templates/"])
let environment = Environment(loader: fsLoader)

let context = ["name": "kyle"]
try environment.renderTemplate(name: "index.html", context: context)
```

--------------------------------

### Render a basic Stencil template

Source: https://stencil.fuller.li/en/latest/getting-started

This snippet demonstrates the simplest way to render a Stencil template. It creates a Template instance with a template string and then calls the render method, providing a context dictionary for variable substitution.

```Swift
let template = Template(templateString: "Hello {{ name }}")
try template.render(["name": "kyle"])
```

--------------------------------

### Render Stencil template using Environment for advanced usage

Source: https://stencil.fuller.li/en/latest/_sources/getting-started.rst

Illustrates a more advanced approach to template rendering using the Environment class. An Environment is initialized, and its renderTemplate convenience method is used to process a template string with a provided context.

```swift
let environment = Environment()

let context = ["name": "kyle"]
try environment.renderTemplate(string: "Hello {{ name }}", context: context)
```

--------------------------------

### Build Stencil with Carthage Commands

Source: https://stencil.fuller.li/en/latest/installation

Execute Carthage commands to update dependencies, generate the Xcode project for Stencil, and build the framework.

```Shell
$ carthage update
$ (cd Carthage/Checkouts/Stencil && swift package generate-xcodeproj)
$ carthage build
```

--------------------------------

### Build Stencil with Carthage

Source: https://stencil.fuller.li/en/latest/_sources/installation.rst

After adding Stencil to your Cartfile, use these shell commands to update Carthage dependencies, generate the Xcode project for Stencil, and then build the framework. This prepares the framework for integration into your project.

```shell
$ carthage update
$ (cd Carthage/Checkouts/Stencil && swift package generate-xcodeproj)
$ carthage build
```

--------------------------------

### Example of Rendered Template Output

Source: https://stencil.fuller.li/en/latest/templates

Shows the final HTML output after the base and child templates are combined and rendered with example data. This illustrates how overridden blocks from the child template and inherited blocks from the base template are integrated into the final HTML document.

```HTML
<html>
  <head>
    <title>Notes</title>
  </head>

  <body>
    <aside>
      <ul>
        <li><a href="/">Home</a></li>
        <li><a href="/notes/">Notes</a></li>
      </ul>
    </aside>

    <section>
      <h2>Pick up food</h2>
      <h2>Do laundry</h2>
    </section>
  </body>
</html>
```

--------------------------------

### Add Stencil to Cartfile for Carthage

Source: https://stencil.fuller.li/en/latest/installation

Specify Stencil as a dependency in your Cartfile for Carthage to manage the project's binaries.

```Configuration
github "stencilproject/Stencil" ~> 0.15.1
```

--------------------------------

### Example Stencil Template for Article List

Source: https://stencil.fuller.li/en/latest/index

Demonstrates basic Stencil template syntax including variable interpolation ({{ }}) and iteration (for loop) to display a list of articles.

```Stencil
There are {{ articles.count }} articles.

<ul>
  {% for article in articles %}
    <li>{{ article.title }} by {{ article.author }}</li>
  {% endfor %}
</ul>
```

--------------------------------

### Template `include` Tag and Loader Setup

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Includes another template file into the current one. By default, the current context is passed, but a sub-context can be provided. This tag requires a template loader, demonstrated with a Swift example.

```html+django
{% include "comment.html" %}
```

```html+django
{% include "comment.html" comment %}
```

```swift
let environment = Environment(bundle: [Bundle.main])
let template = environment.loadTemplate(name: "index.html")
```

--------------------------------

### Install Stencil with CocoaPods

Source: https://stencil.fuller.li/en/latest/installation

Add Stencil to your Podfile and run `pod install` to integrate it into your iOS/macOS project using CocoaPods.

```Ruby
pod 'Stencil', '~> 0.15.1'
```

--------------------------------

### Install Stencil with Swift Package Manager

Source: https://stencil.fuller.li/en/latest/installation

Add Stencil as a dependency in your Package.swift file to integrate it into your Swift project using Swift Package Manager.

```Swift
import PackageDescription

let package = Package(
  name: "MyApplication",
  dependencies: [
    .package(url: "https://github.com/stencilproject/Stencil.git", from: "0.15.1"),
  ]
)
```

--------------------------------

### Add Stencil to Cartfile for Carthage

Source: https://stencil.fuller.li/en/latest/_sources/installation.rst

Specify Stencil as a dependency in your Cartfile for Carthage to manage. This line instructs Carthage to fetch the specified version of the Stencil repository.

```text
github "stencilproject/Stencil" ~> 0.15.1
```

--------------------------------

### Initialize Stencil Environment with Custom Extensions

Source: https://stencil.fuller.li/en/latest/custom-template-tags-and-filters

Demonstrates the basic setup for a Stencil environment, showing how to create an `Extension` object to register custom filters and tags, and then how to use this extension when initializing the `Environment` for template rendering.

```Swift
let ext = Extension()
// Register your filters and tags with the extension

let environment = Environment(extensions: [ext])
try environment.renderTemplate(name: "example.html")
```

--------------------------------

### Render Stencil Template in Swift

Source: https://stencil.fuller.li/en/latest/_sources/index.rst

Illustrates how to use the Stencil library in Swift to define a data model, create a rendering context, load a template from the file system, and render it. This example sets up a basic environment for template processing.

```swift
import Stencil

struct Article {
  let title: String
  let author: String
}

let context = [
  "articles": [
    Article(title: "Migrating from OCUnit to XCTest", author: "Kyle Fuller"),
    Article(title: "Memory Management with ARC", author: "Kyle Fuller")
  ]
]

let environment = Environment(loader: FileSystemLoader(paths: ["templates/"]))
let rendered = try environment.renderTemplate(name: "articles.html", context: context)

print(rendered)
```

--------------------------------

### Install Stencil with Swift Package Manager

Source: https://stencil.fuller.li/en/latest/_sources/installation.rst

Add Stencil as a dependency in your Package.swift file to integrate it into your Swift Package Manager project. This snippet shows the required entry for the package.

```swift
import PackageDescription

let package = Package(
  name: "MyApplication",
  dependencies: [
    .package(url: "https://github.com/stencilproject/Stencil.git", from: "0.15.1")
  ]
)
```

--------------------------------

### Install Stencil with CocoaPods

Source: https://stencil.fuller.li/en/latest/_sources/installation.rst

To install Stencil using CocoaPods, add the specified pod entry to your Podfile. After adding, run 'pod install' to integrate the library into your project.

```ruby
pod 'Stencil', '~> 0.15.1'
```

--------------------------------

### Stencil Lazy Value Wrapper Context Example

Source: https://stencil.fuller.li/en/latest/templates

Provides an example of how to define a LazyValueWrapper in the Stencil context. Values wrapped this way are only evaluated when first accessed in the template and are then cached.

```JSON
[
  "magic": LazyValueWrapper(myHeavyCalculations())
]
```

--------------------------------

### Initialize Stencil Environment with Custom Extensions

Source: https://stencil.fuller.li/en/latest/_sources/custom-template-tags-and-filters.rst

This snippet demonstrates the initial setup required to use custom template tags and filters in Stencil. It involves creating an "Extension" object to register custom components and then initializing the "Environment" with this extension, preparing it for template rendering.

```Swift
let ext = Extension()
// Register your filters and tags with the extension

let environment = Environment(extensions: [ext])
try environment.renderTemplate(name: "example.html")
```

--------------------------------

### Implement Custom Stencil Loader

Source: https://stencil.fuller.li/en/latest/api

Provides an example of implementing a custom `Loader` protocol, demonstrating how to define a `loadTemplate` method to retrieve templates from a custom source, such as in-memory storage, and handle cases where a template is not found.

```Swift
class ExampleMemoryLoader: Loader {
  func loadTemplate(name: String, environment: Environment) throws -> Template {
    if name == "index.html" {
      return Template(templateString: "Hello", environment: environment)
    }

    throw TemplateDoesNotExist(name: name, loader: self)
  }
}
```

--------------------------------

### Example Rendered HTML Output from Template Inheritance

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

This HTML snippet illustrates the final rendered output of a web page where template inheritance has been applied. It shows how a sidebar defined in a base template is included, along with content sections populated by child templates, demonstrating the effective combination of parent and child template elements.

```html
<html>
  <head>
    <title>Notes</title>
  </head>

  <body>
    <aside>
      <ul>
        <li><a href="/">Home</a></li>
        <li><a href="/notes/">Notes</a></li>
      </ul>
    </aside>

    <section>
      <h2>Pick up food</h2>
      <h2>Do laundry</h2>
    </section>
  </body>
</html>
```

--------------------------------

### Access Context Values with Subscripting

Source: https://stencil.fuller.li/en/latest/api

Shows how to get and set values within a `Context` instance using dictionary-like subscripting, allowing direct manipulation of context variables.

```Swift
context["key"] = value
let value = context["key"]
```

--------------------------------

### Define Base Template for Inheritance in Stencil

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

Provides an example of a base HTML template (`base.html`) defining reusable structure and `{% block %}` tags that can be overridden by child templates.

```html+django
<html>
  <head>
    <title>{% block title %}Example{% endblock %}</title>
  </head>

  <body>
    <aside>
      {% block sidebar %}
        <ul>
          <li><a href="/">Home</a></li>
          <li><a href="/notes/">Notes</a></li>
        </ul>
      {% endblock %}
    </aside>

    <section>
      {% block content %}{% endblock %}
    </section>
  </body>
</html>
```

--------------------------------

### Extend Base Template and Override Content Blocks

Source: https://stencil.fuller.li/en/latest/templates

Demonstrates how a child template inherits from a base template using `{% extends "base.html" %}` and overrides specific content blocks (e.g., `title`, `content`) using `{% block %}`. This example also shows how to iterate over a collection (`notes`) within a block to dynamically generate content.

```Stencil (Templating)
{% extends "base.html" %}

{% block title %}Notes{% endblock %}

{% block content %}
  {% for note in notes %}
    <h2>{{ note }}</h2>
  {% endfor %}
{% endblock %}
```

--------------------------------

### Register a Simple Custom Filter in Stencil

Source: https://stencil.fuller.li/en/latest/custom-template-tags-and-filters

Illustrates how to register a basic filter named 'double' that processes an input value. If the value is an integer, it returns the value multiplied by two; otherwise, it returns the original value. This example shows a filter without additional arguments.

```Swift
ext.registerFilter("double") { (value: Any?) in
  if let value = value as? Int {
    return value * 2
  }

  return value
}
```

--------------------------------

### Register a Basic Custom Filter in Swift

Source: https://stencil.fuller.li/en/latest/_sources/custom-template-tags-and-filters.rst

This example shows how to register a simple custom filter named 'double'. The filter takes an input "value", checks if it's an "Int", and if so, returns its doubled value. Otherwise, it returns the original value unchanged.

```Swift
ext.registerFilter("double") { (value: Any?) in
  if let value = value as? Int {
    return value * 2
  }

  return value
}
```

--------------------------------

### Stencil 'lowercase' filter for string transformation

Source: https://stencil.fuller.li/en/latest/builtins

Transforms a string to its lowercase equivalent. For example, 'Stencil' becomes 'stencil'. This filter can also be applied to an array of strings to lowercase each string.

```Stencil
{{ "Stencil"|lowercase }}
```

--------------------------------

### Apply Dynamic Filter to String

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Applies a filter whose name is dynamically resolved from the 'myfilter' variable to the 'string' variable. For example, if 'myfilter' resolves to 'uppercase', the 'uppercase' filter will be applied to the 'string' variable.

```html+django
{{ string|filter:myfilter }}
```

--------------------------------

### Stencil 'uppercase' filter for string transformation

Source: https://stencil.fuller.li/en/latest/builtins

Transforms a string to its uppercase equivalent. For example, 'Stencil' becomes 'STENCIL'. This filter can also be applied to an array of strings to uppercase each string.

```Stencil
{{ "Stencil"|uppercase }}
```

--------------------------------

### Stencil 'capitalize' filter for string capitalization

Source: https://stencil.fuller.li/en/latest/builtins

Capitalizes the first letter of a string. For example, 'stencil' becomes 'Stencil'. This filter can also be applied to an array of strings to capitalize each string.

```Stencil
{{ "stencil"|capitalize }}
```

--------------------------------

### Apply Dynamic Filter in Stencil Template

Source: https://stencil.fuller.li/en/latest/builtins

This snippet demonstrates how to apply a filter dynamically in a Stencil template. It uses the `filter` tag to apply a filter whose name is resolved from the `myfilter` variable to the `string` variable. For example, if `myfilter` resolves to 'uppercase', the `uppercase` filter will be applied to the string.

```Stencil Template
{{ string|filter:myfilter }}
```

--------------------------------

### Register a Custom Boolean Filter in Swift

Source: https://stencil.fuller.li/en/latest/_sources/custom-template-tags-and-filters.rst

This example demonstrates registering a custom boolean filter named 'ordinary', which also defines a negative counterpart 'odd'. The filter checks if an integer value is even, returning "true" or "false", and "nil" for non-integer inputs.

```Swift
ext.registerFilter("ordinary", negativeFilterName: "odd") { (value: Any?) in
    if let value = value as? Int {
        return myInt % 2 == 0
    }
    return nil
}
```

--------------------------------

### Initialize Stencil Environment

Source: https://stencil.fuller.li/en/latest/_sources/api.rst

Initializes a basic Stencil `Environment` instance with default settings.

```Swift
let environment = Environment()
```

--------------------------------

### Initialize Stencil Environment with Custom Loader and Extensions

Source: https://stencil.fuller.li/en/latest/_sources/api.rst

Initializes a Stencil `Environment` instance, optionally providing a custom `loader` and `extensions` for advanced configuration.

```Swift
let environment = Environment(loader: ..., extensions: [...])
```

--------------------------------

### Initialize Stencil Environment

Source: https://stencil.fuller.li/en/latest/api

Initializes a basic Stencil `Environment` instance with default settings, ready for template processing.

```Swift
let environment = Environment()
```

--------------------------------

### Initialize Stencil FileSystemLoader

Source: https://stencil.fuller.li/en/latest/_sources/api.rst

Creates a `FileSystemLoader` instance to load templates from specified file system paths or `Bundle` resources.

```Swift
FileSystemLoader(paths: ["./templates"])
```

```Swift
FileSystemLoader(bundle: [Bundle.main])
```

--------------------------------

### Initialize FileSystemLoader with Paths

Source: https://stencil.fuller.li/en/latest/api

Creates a `FileSystemLoader` instance that loads templates from specified file system paths. This is useful for organizing templates in directories.

```Swift
FileSystemLoader(paths: ["./templates"])
```

--------------------------------

### Initialize Stencil Environment with Custom Loader and Extensions

Source: https://stencil.fuller.li/en/latest/api

Initializes a Stencil `Environment` instance, allowing custom template loaders and extensions to be provided during creation for tailored template processing.

```Swift
let environment = Environment(loader: ..., extensions: [...])
```

--------------------------------

### Initialize FileSystemLoader with Bundles

Source: https://stencil.fuller.li/en/latest/api

Creates a `FileSystemLoader` instance that loads templates from specified `Bundle` objects, typically used for templates embedded within an application bundle.

```Swift
FileSystemLoader(bundle: [Bundle.main])
```

--------------------------------

### Initialize Stencil DictionaryLoader

Source: https://stencil.fuller.li/en/latest/_sources/api.rst

Creates a `DictionaryLoader` instance to load templates from an in-memory dictionary mapping names to template strings.

```Swift
DictionaryLoader(templates: ["index.html": "Hello World"])
```

--------------------------------

### Register a Simple Custom Tag in Stencil

Source: https://stencil.fuller.li/en/latest/custom-template-tags-and-filters

Explains how to register a basic template tag named 'custom' that, when used in a template (e.g., `{% custom %}`), simply returns the string 'Hello World'. This illustrates the simplest form of custom tag creation, without argument parsing or context manipulation.

```Swift
ext.registerSimpleTag("custom") { context in
  return "Hello World"
}
```

--------------------------------

### Render Template from Loader

Source: https://stencil.fuller.li/en/latest/api

Shows how to render a template by its name, relying on the `Environment`'s configured template loader to find and process the template file with provided context.

```Swift
let context = ["name": "Kyle"]
let rendered = environment.renderTemplate(name: "example.html", context: context)
```

--------------------------------

### Initialize DictionaryLoader

Source: https://stencil.fuller.li/en/latest/api

Creates a `DictionaryLoader` instance that loads templates from an in-memory dictionary, mapping template names to their string content.

```Swift
DictionaryLoader(templates: ["index.html": "Hello World"])
```

--------------------------------

### Render Stencil Template in Swift

Source: https://stencil.fuller.li/en/latest/index

Illustrates how to integrate and render a Stencil template within a Swift application. It defines a data structure, prepares a rendering context, loads a template from the file system, and renders it to a string.

```Swift
import Stencil

struct Article {
  let title: String
  let author: String
}

let context = [
  "articles": [
    Article(title: "Migrating from OCUnit to XCTest", author: "Kyle Fuller"),
    Article(title: "Memory Management with ARC", author: "Kyle Fuller")
  ]
]

let environment = Environment(loader: FileSystemLoader(paths: ["templates/"]))
let rendered = try environment.renderTemplate(name: "articles.html", context: context)

print(rendered)
```

--------------------------------

### Implement Custom Stencil Loader Protocol

Source: https://stencil.fuller.li/en/latest/_sources/api.rst

Demonstrates how to implement a custom `Loader` protocol in Stencil, providing a `loadTemplate` method to handle template retrieval and error handling.

```Swift
class ExampleMemoryLoader: Loader {
  func loadTemplate(name: String, environment: Environment) throws -> Template {
    if name == "index.html" {
      return Template(templateString: "Hello", environment: environment)
    }

    throw TemplateDoesNotExist(name: name, loader: self)
  }
}
```

--------------------------------

### Stencil Variable Output Syntax

Source: https://stencil.fuller.li/en/latest/templates

Shows the fundamental syntax for displaying variable values in Stencil templates using double curly braces.

```Stencil
{{ variable }}
```

--------------------------------

### Render Template from String

Source: https://stencil.fuller.li/en/latest/api

Demonstrates how to render a template directly from a string using the `renderTemplate(string:context:)` method of the `Environment`, passing a dictionary for context variables.

```Swift
let template = "Hello {{ name }}"
let context = ["name": "Kyle"]
let rendered = environment.renderTemplate(string: template, context: context)
```

--------------------------------

### Render Articles List with Stencil Template (HTML+Django)

Source: https://stencil.fuller.li/en/latest/_sources/index.rst

Demonstrates basic Stencil template syntax for iterating over a list of articles and displaying their titles and authors. Shows variable access and loop constructs within an HTML structure.

```html+django
There are {{ articles.count }} articles.

<ul>
  {% for article in articles %}
    <li>{{ article.title }} by {{ article.author }}</li>
  {% endfor %}
</ul>
```

--------------------------------

### Render Stencil Template from String

Source: https://stencil.fuller.li/en/latest/_sources/api.rst

Renders a Stencil template directly from a given string, providing a context dictionary for variable substitution.

```Swift
let template = "Hello {{ name }}"
let context = ["name": "Kyle"]
let rendered = environment.renderTemplate(string: template, context: context)
```

--------------------------------

### Define Base Template with Reusable Blocks

Source: https://stencil.fuller.li/en/latest/templates

Illustrates how to create a base HTML template (`base.html`) that defines reusable content blocks (e.g., `title`, `sidebar`, `content`) using `{% block %}` tags. These blocks can be overridden by child templates, promoting code reuse and consistent page structure.

```Stencil (Templating)
<html>
  <head>
    <title>{% block title %}Example{% endblock %}</title>
  </head>

  <body>
    <aside>
      {% block sidebar %}
        <ul>
          <li><a href="/">Home</a></li>
          <li><a href="/notes/">Notes</a></li>
        </ul>
      {% endblock %}
    </aside>

    <section>
      {% block content %}{% endblock %}
    </section>
  </body>
</html>
```

--------------------------------

### Render Stencil Template from Named File

Source: https://stencil.fuller.li/en/latest/_sources/api.rst

Renders a Stencil template loaded by name from the configured loader, providing a context dictionary for variable substitution.

```Swift
let context = ["name": "Kyle"]
let rendered = environment.renderTemplate(name: "example.html", context: context)
```

--------------------------------

### Register a Simple Custom Tag in Swift

Source: https://stencil.fuller.li/en/latest/_sources/custom-template-tags-and-filters.rst

This snippet shows the simplest way to register a custom template tag named 'custom'. When used in a template, this tag will render the static string 'Hello World'. It's suitable for tags that don't require arguments or complex parsing.

```Swift
ext.registerSimpleTag("custom") { context in
  return "Hello World"
}
```

--------------------------------

### Flatten Context to Dictionary

Source: https://stencil.fuller.li/en/latest/api

Demonstrates the `flatten()` method, which combines all levels of the `Context` stack into a single dictionary, providing a complete view of all accessible variables.

```Swift
let dictionary = context.flatten()
```

--------------------------------

### Template Operator Precedence

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Demonstrates how operator precedence works in the template language, showing the default behavior and how parentheses can be used to override it.

```html+django
{% if one or two and three %}
```

```text
one or (two and three)
```

```html+django
{% if (one or two) and three %}
```

```text
(one or two) and three
```

--------------------------------

### Load Stencil Template by Name

Source: https://stencil.fuller.li/en/latest/_sources/api.rst

Loads a Stencil template by its name from the environment's configured loader, returning a `Template` object.

```Swift
let template = try environment.loadTemplate(name: "example.html")
```

--------------------------------

### Stencil Variable Property and Index Access

Source: https://stencil.fuller.li/en/latest/templates

Demonstrates accessing properties (like count, first) and elements by index (.1) on variables. It also illustrates indirect evaluation using the subscript operator [] where the key itself is a variable.

```Stencil
There are {{ people.count }} people. {{ people.first }} is the first
person, followed by {{ people.1 }}.
```

```JSON
[
  "item": [
    "name": "John"
  ],
  "key": "name"
]
```

```Stencil
The result of {{ item[key] }} will be the same as {{ item.name }}. It will first evaluate the result of {{ key }}, and only then evaluate the lookup expression.
```

--------------------------------

### Access Stencil Context Variables via Subscript

Source: https://stencil.fuller.li/en/latest/_sources/api.rst

Shows how to set and retrieve values from a Stencil `Context` instance using dictionary-like subscripting.

```Swift
context["key"] = value
let value = context["key"]
```

--------------------------------

### Stencil Iteration 'for' Tag

Source: https://stencil.fuller.li/en/latest/templates

Illustrates the 'for' tag for iterating over collections in Stencil templates. It shows how to loop through items and access each item within the loop.

```Stencil
{% for item in items %}
  {{ item }}
{% endfor %}
```

--------------------------------

### Load Template from Loader

Source: https://stencil.fuller.li/en/latest/api

Illustrates how to load a `Template` object from the `Environment`'s configured loader using its name. This loaded template can then be rendered or further processed.

```Swift
let template = try environment.loadTemplate(name: "example.html")
```

--------------------------------

### Flatten Stencil Context to Dictionary

Source: https://stencil.fuller.li/en/latest/_sources/api.rst

Demonstrates how to flatten the entire Stencil `Context` stack into a single dictionary, including all variables from all scopes.

```Swift
let dictionary = context.flatten()
```

--------------------------------

### Swift Context for Stencil Subscript Operator

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

Provides a Swift dictionary context demonstrating how a nested value and a key variable can be set up for use with Stencil's subscript operator.

```swift
[
  "item": [
    "name": "John"
  ],
  "key": "name"
]
```

--------------------------------

### Stencil Filter Application

Source: https://stencil.fuller.li/en/latest/templates

Shows the syntax for applying filters to variables in Stencil templates. Filters transform the variable's value, as demonstrated with the uppercase filter.

```Stencil
{{ variable|uppercase }}
```

--------------------------------

### Iterate Over Collections with For Tag in Stencil

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

Shows how to use the `{% for ... in ... %}` tag to iterate over a collection of items in a Stencil template, rendering content for each item.

```html+django
{% for item in items %}
  {{ item }}
{% endfor %}
```

--------------------------------

### Stencil 'include' tag for template reuse

Source: https://stencil.fuller.li/en/latest/builtins

Includes another template into the current one. By default, the included file receives the current context. An optional second parameter allows passing a specific sub-context. Requires a template loader to lookup the template.

```Stencil
{% include "comment.html" %}
```

```Stencil
{% include "comment.html" comment %}
```

```Swift
let environment = Environment(bundle: [Bundle.main])
let template = environment.loadTemplate(name: "index.html")
```

--------------------------------

### Swift Context for Lazy Value Evaluation in Stencil

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

Demonstrates how to use `LazyValueWrapper` in a Swift context to defer the evaluation of heavy computations until the value is first accessed in a Stencil template.

```swift
[
  "magic": LazyValueWrapper(myHeavyCalculations())
]
```

--------------------------------

### Push Scope onto Stencil Context

Source: https://stencil.fuller.li/en/latest/_sources/api.rst

Illustrates pushing a new scope onto the Stencil `Context` stack, allowing temporary variable modifications that are automatically reverted when the closure finishes.

```Swift
context.push(["name": "example"]) {
    // context contains name which is `example`.
}

// name is popped off the context after the duration of the closure.
```

--------------------------------

### Extend Base Template and Override Blocks in Stencil

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

Demonstrates how a child template uses `{% extends %}` to inherit from a base template and then overrides specific `{% block %}` sections to customize content.

```html+django
{% extends "base.html" %}

{% block title %}Notes{% endblock %}

{% block content %}
  {% for note in notes %}
    <h2>{{ note }}</h2>
  {% endfor %}
{% endblock %}
```

--------------------------------

### Push New Scope onto Context

Source: https://stencil.fuller.li/en/latest/api

Illustrates the `push()` method of `Context`, which allows temporarily adding a new scope of variables. Changes within the closure are isolated and automatically reverted when the closure completes.

```Swift
context.push(["name": "example"]) {
    // context contains name which is `example`.
}

// name is popped off the context after the duration of the closure.
```

--------------------------------

### Stencil Template Comment

Source: https://stencil.fuller.li/en/latest/templates

Explains the syntax for adding comments in Stencil templates. Comments are enclosed in {# ... #} and are completely ignored during template rendering.

```Stencil
{# My comment is completely hidden #}
```

--------------------------------

### Stencil Conditional 'if' Tag

Source: https://stencil.fuller.li/en/latest/templates

Demonstrates the basic usage of the 'if' tag for conditional control flow in Stencil templates. The content within the 'if' block is rendered only if the condition is true.

```Stencil
{% if variable %}
  {{ variable }} was found.
{% endif %}
```

--------------------------------

### Stencil `for` Tag: Iteration and Control

Source: https://stencil.fuller.li/en/latest/builtins

The `for` tag allows iteration over arrays, dictionaries, and ranges. It supports conditional filtering with `where`, an `empty` block for empty lists, and provides loop variables like `first`, `last`, `counter`. It also supports labeled loops for nested context access.

```Stencil
<ul>
  {% for user in users %}
    <li>{{ user }}</li>
  {% endfor %}
</ul>
```

```Stencil
<ul>
  {% for key, value in dict %}
    <li>{{ key }}: {{ value }}</li>
  {% endfor %}
</ul>
```

```Stencil
<ul>
  {% for i in 1...array.count %}
    <li>{{ i }}</li>
  {% endfor %}
</ul>
```

```Stencil
<ul>
  {% for user in users where user.name != "Kyle" %}
    <li>{{ user }}</li>
  {% endfor %}
</ul>
```

```Stencil
<ul>
  {% for user in users %}
    <li>{{ user }}</li>
  {% empty %}
    <li>There are no users.</li>
  {% endfor %}
</ul>
```

```Stencil
{% for user in users %}
  {% if forloop.first %}
    This is the first user.
  {% endif %}
{% endfor %}
```

```Stencil
{% for user in users %}
  This is user number {{ forloop.counter }} user.
{% endfor %}
```

```Stencil
{% outer: for item in users %}
  {% for item in 1..3 %}
    {% if forloop.outer.first %}
      This is the first user.
    {% endif %}
  {% endfor %}
{% endfor %}
```

--------------------------------

### Stencil Built-in Template Tags and Filters Reference

Source: https://stencil.fuller.li/en/latest/builtins

This section provides a comprehensive reference for the built-in template tags and filters available in Stencil, a template language for Swift. It lists various control flow tags like `for`, `if`, `block`, and data transformation filters such as `capitalize`, `uppercase`, `lowercase`, and `filter`.

```APIDOC
Built-in Template Tags:
  - for
  - break
  - continue
  - if
    - Operators:
      - ==
      - !=
      - <
      - <=
      - >
      - >=
  - ifnot
  - now
  - filter
  - include
  - extends
  - block

Built-in Filters:
  - capitalize
  - uppercase
  - lowercase
  - default
  - join
  - split
  - indent
  - filter
```

--------------------------------

### Stencil `if` Tag: Conditional Logic and Operators

Source: https://stencil.fuller.li/en/latest/builtins

The `if` tag evaluates conditions and renders content conditionally, supporting `elif` and `else` blocks. It allows combining conditions with `and`, `or`, `not` operators, and supports parentheses for precedence control, as well as the `==` equality operator.

```Stencil
{% if admin %}
  The user is an administrator.
{% elif user %}
  A user is logged in.
{% else %}
  No user was found.
{% endif %}
```

```Stencil
{% if one and two %}
    Both one and two evaluate to true.
{% endif %}

{% if not one %}
    One evaluates to false
{% endif %}

{% if one or two %}
    Either one or two evaluates to true.
{% endif %}

{% if not one or two %}
    One does not evaluate to false or two evaluates to true.
{% endif %}
```

```Stencil
{% if one or two and three %}
```

```Stencil
{% if (one or two) and three %}
```

```Stencil
{% if value == other_value %}
  value is equal to other_value
{% endif %}
```

--------------------------------

### Stencil Boolean Expression Output

Source: https://stencil.fuller.li/en/latest/templates

Illustrates how boolean expressions can be evaluated and rendered directly within Stencil templates, outputting 'true' or 'false'.

```Stencil
{{ variable == 1 }}
```

--------------------------------

### Access Array Elements and Properties in Stencil

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

Illustrates accessing array properties like `count`, `first`, and elements by index in a Stencil template. This shows Stencil's variable lookup capabilities.

```html+django
There are {{ people.count }} people. {{ people.first }} is the first
person, followed by {{ people.1 }}.
```

--------------------------------

### Register a Custom Filter with Arguments in Stencil

Source: https://stencil.fuller.li/en/latest/custom-template-tags-and-filters

Shows how to create a filter named 'multiply' that accepts an integer argument. The filter multiplies the input value by this argument. It includes error handling for cases where the argument is missing or not an integer, demonstrating how to access and validate filter arguments.

```Swift
ext.registerFilter("multiply") { (value: Any?, arguments: [Any?]) in
  let amount: Int

  if let value = arguments.first as? Int {
    amount = value
  } else {
    throw TemplateSyntaxError("multiple tag must be called with an integer argument")
  }

  if let value = value as? Int {
    return value * amount
  }

  return value
}
```

--------------------------------

### Conditional Logic with If Tag in Stencil

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

Demonstrates using the `{% if ... %}` tag for conditional rendering in Stencil templates. Content inside the block is rendered only if the condition is true.

```html+django
{% if variable %}
  {{ variable }} was found.
{% endif %}
```

--------------------------------

### Apply Filters to Variables in Stencil

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

Illustrates the syntax for applying a filter to a variable in a Stencil template, transforming its value (e.g., `uppercase`).

```html+django
{{ variable|uppercase }}
```

--------------------------------

### Use Subscript Operator for Dynamic Variable Lookup in Stencil

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

Shows how to use the subscript operator `item[key]` in Stencil templates for dynamic variable lookup, where the key itself is a variable. Compares it to direct property access.

```html+django
The result of {{ item[key] }} will be the same as {{ item.name }}. It will first evaluate the result of {{ key }}, and only then evaluate the lookup expression.
```

--------------------------------

### Template `split` Filter

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Splits a string into an array of substrings using a specified separator. The input value must be a string, and the default separator is a single space.

```html+django
{{ value|split:", " }}
```

--------------------------------

### Print Variable Value in Stencil Template

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

Demonstrates how to print the value of a variable in a Stencil template using the `{{ ... }}` syntax.

```html+django
{{ variable }}
```

--------------------------------

### Template `join` Filter

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Joins elements of an array into a single string using a specified separator. The input value must be an array, and the default separator is an empty string.

```html+django
{{ value|join:", " }}
```

--------------------------------

### Template `indent` Filter

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Indents lines of the rendered value or block. It accepts arguments for indentation width, character, and whether to indent the first line.

```html+django
{{ value|indent:2," ",true }}
```

--------------------------------

### Stencil 'indent' filter for text formatting

Source: https://stencil.fuller.li/en/latest/builtins

Indents lines of the rendered value or block. It accepts arguments for indentation width (default 4), indentation character (default space), and whether to indent the first line (default false).

```Stencil
{{ value|indent:2," ",true }}
```

--------------------------------

### Stencil 'default' filter for fallback values

Source: https://stencil.fuller.li/en/latest/builtins

Provides a default value if the variable is not present in the context. If the variable exists, its value is used instead of the default.

```Stencil
Hello {{ name|default:"World" }}
```

--------------------------------

### Render Boolean Expressions in Stencil

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

Shows how to render a boolean expression directly in a Stencil template. The output will be 'true' or 'false' based on the expression's evaluation.

```html+django
{{ variable == 1 }}
```

--------------------------------

### Stencil `for` loop tag

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

The `for` tag iterates over collections like arrays, dictionaries, and ranges. It supports filtering with a `where` clause, an `empty` block for no results, and provides loop context variables (`forloop.first`, `forloop.counter`). Nested loops can be labeled for external access.

```html+django
<ul>
  {% for user in users %}
    <li>{{ user }}</li>
  {% endfor %}
</ul>
```

```html+django
<ul>
  {% for key, value in dict %}
    <li>{{ key }}: {{ value }}</li>
  {% endfor %}
</ul>
```

```html+django
<ul>
  {% for i in 1...array.count %}
    <li>{{ i }}</li>
  {% endfor %}
</ul>
```

```html+django
<ul>
  {% for user in users where user.name != "Kyle" %}
    <li>{{ user }}</li>
  {% endfor %}
</ul>
```

```html+django
<ul>
  {% for user in users %}
    <li>{{ user }}</li>
  {% empty %}
    <li>There are no users.</li>
  {% endfor %}
</ul>
```

```html+django
{% for user in users %}
  {% if forloop.first %}
    This is the first user.
  {% endif %}
{% endfor %}
```

```html+django
{% for user in users %}
  This is user number {{ forloop.counter }} user.
{% endfor %}
```

```html+django
{% outer: for item in users %}
  {% for item in 1..3 %}
    {% if forloop.outer.first %}
      This is the first user.
    {% endif %}
  {% endfor %}
{% endfor %}
```

--------------------------------

### Stencil 'filter' tag for content transformation

Source: https://stencil.fuller.li/en/latest/builtins

Applies one or more filters to the content within the block. Multiple filters can be chained using a pipe (`|`) character, applying them sequentially.

```Stencil
{% filter lowercase %}
  This Text Will Be Lowercased.
{% endfilter %}
```

```Stencil
{% filter lowercase|capitalize %}
  This Text Will First Be Lowercased, Then The First Character Will BE
  Capitalised.
{% endfilter %}
```

--------------------------------

### Stencil 'split' filter for string division

Source: https://stencil.fuller.li/en/latest/builtins

Splits a string into an array of substrings based on a specified separator. The input value MUST be a string. The default separator is a single-space string.

```Stencil
{{ value|split:", " }}
```

--------------------------------

### Stencil 'join' filter for array concatenation

Source: https://stencil.fuller.li/en/latest/builtins

Joins elements of an array into a single string using a specified separator. The input value MUST be an array. The default separator is an empty string.

```Stencil
{{ value|join:", " }}
```

--------------------------------

### Template `uppercase` Filter

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Converts a string to its uppercase equivalent. This filter can also be applied to an array of strings to transform each element.

```html+django
{{ "Stencil"|uppercase }}
```

--------------------------------

### Template Less Than Operator (<)

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Compares if the first value is less than the second. This operator only supports numerical types.

```html+django
{% if value < other_value %}
  value is less than other_value
{% endif %}
```

--------------------------------

### Stencil `continue` Tag: Skipping Iterations

Source: https://stencil.fuller.li/en/latest/builtins

The `continue` tag skips the remainder of the current loop iteration and proceeds to the next one. It can also skip iterations in outer loops using an optional label.

```Stencil
{% for user in users %}
  {% if user.inaccessible %}
    {% continue %}
  {% endif %}
  This is user {{ user.name }}.
{% endfor %}
```

```Stencil
{% outer: for user in users %}
  {% for address in user.addresses %}
    {% if address.isInvalid %}
      {% continue outer %}
    {% endif %}
  {% endfor %}
{% endfor %}
```

--------------------------------

### Add Comments to Stencil Templates

Source: https://stencil.fuller.li/en/latest/_sources/templates.rst

Explains how to add comments to a Stencil template using `{# ... #}`. These comments are not included in the final rendered output.

```html+django
{# My comment is completely hidden #}
```

--------------------------------

### Template `lowercase` Filter

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Converts a string to its lowercase equivalent. This filter can also be applied to an array of strings to transform each element.

```html+django
{{ "Stencil"|lowercase }}
```

--------------------------------

### Stencil `if` conditional tag

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

The `if` tag evaluates a condition and renders content if true. It supports `elif` and `else` for multiple conditions. Conditions can use logical operators (`and`, `or`, `not`) with defined precedence. Truthiness is determined by presence, non-emptiness, non-false boolean, non-zero number, and non-empty string.

```html+django
{% if admin %}
  The user is an administrator.
{% elif user %}
  A user is logged in.
{% else %}
  No user was found.
{% endif %}
```

```html+django
{% if one and two %}
    Both one and two evaluate to true.
{% endif %}
```

```html+django
{% if not one %}
    One evaluates to false
{% endif %}
```

```html+django
{% if one or two %}
    Either one or two evaluates to true.
{% endif %}
```

```html+django
{% if not one or two %}
    One does not evaluate to false or two evaluates to true.
{% endif %}
```

--------------------------------

### Template `filter` Tag

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Applies one or more filters to the content within the block. Multiple filters can be chained using the pipe (`|`) character for sequential transformations.

```html+django
{% filter lowercase %}
  This Text Will Be Lowercased.
{% endfilter %}
```

```html+django
{% filter lowercase|capitalize %}
  This Text Will First Be Lowercased, Then The First Character Will BE
  Capitalised.
{% endfilter %}
```

--------------------------------

### Stencil 'ifnot' tag for checking variable absence

Source: https://stencil.fuller.li/en/latest/builtins

Checks if a variable is NOT found in the current context. Note that `{% ifnot %}` is deprecated; it is recommended to use `{% if not %}` instead.

```Stencil
{% ifnot variable %}
  The variable was NOT found in the current context.
{% else %}
  The variable was found.
{% endif %}
```

--------------------------------

### Register a Custom Filter with Arguments in Swift

Source: https://stencil.fuller.li/en/latest/_sources/custom-template-tags-and-filters.rst

This snippet illustrates how to register a custom filter that accepts arguments. The 'multiply' filter expects an integer argument, which it uses to multiply the input value. It includes error handling for missing or incorrect argument types.

```Swift
ext.registerFilter("multiply") { (value: Any?, arguments: [Any?]) in
  let amount: Int

  if let value = arguments.first as? Int {
    amount = value
  } else {
    throw TemplateSyntaxError("multiple tag must be called with an integer argument")
  }

  if let value = value as? Int {
    return value * amount
  }

  return value
}
```

--------------------------------

### Template `extends` Tag

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Extends the current template from a specified parent template, enabling template inheritance and allowing child templates to override or extend blocks defined in the parent.

```html+django
{% extends "base.html" %}
```

--------------------------------

### Stencil '<=' operator for less than or equal comparison

Source: https://stencil.fuller.li/en/latest/builtins

Compares two values to check if the first is less than or equal to the second. This operator only supports numerical types.

```Stencil
{% if value <= other_value %}
  value is less than or equal to other_value
{% endif %}
```

--------------------------------

### Stencil `continue` tag

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

The `continue` tag skips the remaining statements in the current iteration of a `for` loop and proceeds to the next iteration. It supports an optional label to skip iterations in outer nested loops.

```html+django
{% for user in users %}
  {% if user.inaccessible %}
    {% continue %}
  {% endif %}
  This is user {{ user.name }}.
{% endfor %}
```

```html+django
{% outer: for user in users %}
  {% for address in user.addresses %}
    {% if address.isInvalid %}
      {% continue outer %}
    {% endif %}
  {% endfor %}
{% endfor %}
```

--------------------------------

### Stencil '!=' operator for inequality comparison

Source: https://stencil.fuller.li/en/latest/builtins

Compares two values for inequality. This operator supports numerical, string, and boolean types.

```Stencil
{% if value != other_value %}
  value is not equal to other_value
{% endif %}
```

--------------------------------

### Register a Custom Boolean Filter in Stencil

Source: https://stencil.fuller.li/en/latest/custom-template-tags-and-filters

Demonstrates registering a filter 'ordinary' with a corresponding negative filter 'odd'. This filter checks if an integer is even, returning a boolean result. It highlights the capability to define inverse filters for conditional logic.

```Swift
ext.registerFilter("ordinary", negativeFilterName: "odd") { (value: Any?) in
    if let value = value as? Int {
        return value % 2 == 0
    }
    return nil
}
```

--------------------------------

### Template Inequality Operator (!=)

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Compares two values for inequality. This operator supports numerical, string, and boolean types.

```html+django
{% if value != other_value %}
  value is not equal to other_value
{% endif %}
```

--------------------------------

### Template Less Than or Equal Operator (<=)

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Compares if the first value is less than or equal to the second. This operator only supports numerical types.

```html+django
{% if value <= other_value %}
  value is less than or equal to other_value
{% endif %}
```

--------------------------------

### Stencil 'extends' tag for template inheritance

Source: https://stencil.fuller.li/en/latest/builtins

Extends the current template from a parent template, enabling template inheritance. This allows child templates to override or extend blocks defined in the parent.

```Stencil
{% extends "base.html" %}
```

--------------------------------

### Stencil '<' operator for less than comparison

Source: https://stencil.fuller.li/en/latest/builtins

Compares two values to check if the first is less than the second. This operator only supports numerical types.

```Stencil
{% if value < other_value %}
  value is less than other_value
{% endif %}
```

--------------------------------

### Template `default` Filter

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Provides a default value if the variable is not present in the context. Otherwise, it uses the actual value of the variable.

```html+django
Hello {{ name|default:"World" }}
```

--------------------------------

### Template `block` Tag

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Defines a content block within a template that can be overridden or extended by child templates, facilitating template inheritance and modular design.

```html+django
{% block content %}
  <!-- Default content -->
{% endblock %}
```

--------------------------------

### Template Equality Operator (==)

Source: https://stencil.fuller.li/en/latest/_sources/builtins.rst

Compares two values for equality. This operator supports numerical, string, and boolean types.

```html+django
{% if value == other_value %}
  value is equal to other_value
{% endif %}
```
Tokens:
Raw