`wire.compile`

import wire.compile

wire does not re-export this module, so it is reached only by importing it directly.

Turning a parsed template into the instruction tree the renderer walks.

Wire compiles rather than substitutes. A template is parsed once, every expression in it is parsed once, every directive is resolved once, and what comes out is a tree of plain instructions that holds no reference back to the document it came from. Rendering that tree is then a walk with no parsing in it at all, which is what lets the same page be rendered thousands of times from one compile, and what lets the renderer know the exact escaping context of every interpolation instead of guessing at it.

Compiling is also where a template’s mistakes are found. An unknown directive, an expression that does not parse, an x-else with no x-if in front of it, the same region defined twice: all of them are reported here, once, rather than on the request that happens to reach them.

Functions

`compile()`

wire.compile.compile(source: string, path: string, context, options: ?dict) -> Template

Compiles source into a Template.

context names the element the result will sit inside, and should be nil for a template rendered on its own. options takes compact (drop whitespace-only text, default false) and comments (keep HTML comments, default false).

import wire

var template = wire.compile.compile(
  '<p x-if="user">Hello {{ user.name }}</p>', 'greeting.html', nil, nil
)

Parameters

source (string)
path (string)
context (?string)
options (?dict)

Returns Template

Raises TemplateSyntaxError

Classes

`Segment`

class wire.compile.Segment

One piece of a run of text or of an attribute value: either literal characters or an expression to evaluate.

Fields

Field	Type	Description
`text`		The literal characters, or `nil` when this is an expression.
`value`		The expression, or `nil` when this is literal text.

Field	Type	Description
`kind`		What kind of instruction this is.
`line`		The line of the tag it came from, or `0`.
`column`		The column of that tag, or `0`.

Field	Type	Description
`name`		The attribute’s name.
`segments`		The literal and interpolated pieces of its value.
`context`		The escaping context its interpolations need, decided by the attribute’s name.
`url_list`		True when the attribute holds several URLs rather than one, so each has to be checked on its own.
`url_descriptors`		True when each URL in the list may be followed by a descriptor, as `srcset` allows and `ping` does not.

Field	Type	Description
`tag`		The tag name, as it will be written.
`attributes`		The attributes written literally on the element.
`spreads`		Expressions giving further attributes, from `x-attr`, applied after the literal ones so a computed value wins.
`children`		The instructions for the element’s children.
`void`		True for an element written without a closing tag.
`content`		An expression replacing the element’s children, from `x-text` or `x-html`, or `nil`.
`content_raw`		True when `content` came from `x-html` and must not be escaped.

Field	Type	Description
`test`		The expression being tested, or `nil` for the final `x-else`.
`negate`		True when the arm renders on a falsy test, which is what `x-not` means.
`body`		The instruction to render when the arm is taken.

Keyboard shortcuts

The Zuri Standard Library