Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Templates ¶
type Templates struct {
// The root path from which to load files. Required if template functions
// accessing the file system are used (such as include). Default is
// `{http.vars.root}` if set, or current working directory otherwise.
FileRoot string `json:"file_root,omitempty"`
// The MIME types for which to render templates. It is important to use
// this if the route matchers do not exclude images or other binary files.
// Default is text/plain, text/markdown, and text/html.
MIMETypes []string `json:"mime_types,omitempty"`
// The template action delimiters.
Delimiters []string `json:"delimiters,omitempty"`
}
Templates is a middleware which executes response bodies as Go templates. The syntax is documented in the Go standard library's [text/template package](https://golang.org/pkg/text/template/).
⚠️ Template functions/actions are still experimental, so they are subject to change.
[All Sprig functions](https://masterminds.github.io/sprig/) are supported.
In addition to the standard functions and Sprig functions, Caddy adds extra functions and data that are available to a template:
##### `.Args`
Access arguments passed to this page/context, for example as the result of a `include`.
``` {{.Args 0}} // first argument ```
##### `.Cookie`
Gets the value of a cookie by name.
``` {{.Cookie "cookiename"}} ```
##### `env`
Gets an environment variable.
``` {{env "VAR_NAME"}} ```
##### `placeholder`
Gets an [placeholder variable](/docs/conventions#placeholders). The braces (`{}`) have to be omitted.
``` {{placeholder "http.request.uri.path"}} {{placeholder "http.error.status_code"}} ```
##### `.Host`
Returns the hostname portion (no port) of the Host header of the HTTP request.
``` {{.Host}} ```
##### `httpInclude`
Includes the contents of another file by making a virtual HTTP request (also known as a sub-request). The URI path must exist on the same virtual server because the request does not use sockets; instead, the request is crafted in memory and the handler is invoked directly for increased efficiency.
``` {{httpInclude "/foo/bar?q=val"}} ```
##### `include`
Includes the contents of another file. Optionally can pass key-value pairs as arguments to be accessed by the included file.
``` {{include "path/to/file.html"}} // no arguments {{include "path/to/file.html" "arg1" 2 "value 3"}} // with arguments ```
##### `listFiles`
Returns a list of the files in the given directory, which is relative to the template context's file root.
``` {{listFiles "/mydir"}} ```
##### `markdown`
Renders the given Markdown text as HTML.
``` {{markdown "My _markdown_ text"}} ```
##### `.RemoteIP`
Returns the client's IP address.
``` {{.RemoteIP}} ```
##### `.Req`
Accesses the current HTTP request, which has various fields, including:
- `.Method` - the method
- `.URL` - the URL, which in turn has component fields (Scheme, Host, Path, etc.)
- `.Header` - the header fields
- `.Host` - the Host or :authority header of the request
``` {{.Req.Header.Get "User-Agent"}} ```
##### `.RespHeader.Add`
Adds a header field to the HTTP response.
``` {{.RespHeader.Add "Field-Name" "val"}} ```
##### `.RespHeader.Del`
Deletes a header field on the HTTP response.
``` {{.RespHeader.Del "Field-Name"}} ```
##### `.RespHeader.Set`
Sets a header field on the HTTP response, replacing any existing value.
``` {{.RespHeader.Set "Field-Name" "val"}} ```
##### `splitFrontMatter`
Splits front matter out from the body. Front matter is metadata that appears at the very beginning of a file or string. Front matter can be in YAML, TOML, or JSON formats:
**TOML** front matter starts and ends with `+++`:
``` +++ template = "blog" title = "Blog Homepage" sitename = "A Caddy site" +++ ```
**YAML** is surrounded by `---`:
``` --- template: blog title: Blog Homepage sitename: A Caddy site --- ```
**JSON** is simply `{` and `}`:
```
{
"template": "blog",
"title": "Blog Homepage",
"sitename": "A Caddy site"
}
```
The resulting front matter will be made available like so:
- `.Meta` to access the metadata fields, for example: `{{$parsed.Meta.title}}` - `.Body` to access the body after the front matter, for example: `{{markdown $parsed.Body}}`
##### `stripHTML`
Removes HTML from a string.
``` {{stripHTML "Shows <b>only</b> text content"}} ```
func (Templates) CaddyModule ¶
func (Templates) CaddyModule() caddy.ModuleInfo
CaddyModule returns the Caddy module information.
Source Files