html

type Attribute ¶

type Attribute struct {
	Key   string
	Value string
}

Attribute represents an HTML attribute with key and value. Like the other node types it lives in a NodeList as a pointer (*Attribute); its Dump method has a pointer receiver, so a bare Attribute value does not satisfy Node.

func (a *Attribute) Dump(indent int) string

type AttributeEntityEncodingFromTo ¶

type AttributeEntityEncodingFromTo struct {
	From string
	To   string
}

AttributeEntityEncodingFromTo specifies a pair of strings used during HTML attribute value encoding.

type CommentNode ¶

type CommentNode struct {
	Text string
	Line int
}

CommentNode represents an HTML <!-- ... --> comment.

func (c *CommentNode) Dump(indent int) string

type ConfiguredNodeList ¶

type ConfiguredNodeList struct {
	Nodes  NodeList
	Config IndentConfig
}

ConfiguredNodeList wraps a NodeList with the IndentConfig under which it should format. NewAdminParser and NewStorefrontParser return this so the caller can Dump(0) without managing config separately.

func NewAdminParser(input string) (ConfiguredNodeList, error)

func NewStorefrontParser(input string) (ConfiguredNodeList, error)

func (cnl ConfiguredNodeList) Dump(indent int) string

type ElementNode ¶

type ElementNode struct {
	Tag         string
	Attributes  NodeList
	Children    NodeList
	SelfClosing bool
	// Unclosed reports that the element opened with `<tag>` but its
	// children parser yielded on an outer Twig terminator (e.g.
	// `{% endblock %}`) before reaching `</tag>`. The closing tag is
	// elsewhere in the source, typically wrapped in another control-flow
	// block. The formatter therefore does NOT emit `</tag>` for unclosed
	// elements — the matching `</tag>` lives as a RawNode further down.
	Unclosed bool
	Line     int
}

ElementNode represents an HTML element.

func (e *ElementNode) Dump(indent int) string

type IndentConfig ¶

type IndentConfig struct {
	SpaceIndent             bool
	IndentSize              int
	TwigBlockIndentChildren bool
}

IndentConfig controls how the formatter emits indentation.

func DefaultIndentConfig() IndentConfig

func (c IndentConfig) GetIndent() string

type Node ¶

type Node interface {
	Dump(indent int) string
}

Node is the interface for nodes in the AST.

type NodeList ¶

type NodeList []Node

NodeList is a sequence of AST nodes. It has its own Dump method that arranges children with appropriate inter-node whitespace.

func NewParser(input string) (NodeList, error)

func NewParserWithConfig(input string, config IndentConfig) (NodeList, error)

func (nodeList NodeList) Dump(indent int) string

type ParentNode ¶

type ParentNode struct {
	Trim TwigTrim
	Line int
}

ParentNode represents `{% parent %}` or `{% parent() %}`.

func (p *ParentNode) Dump(indent int) string

type ParseError ¶

type ParseError struct {
	Filename string
	Pos      Pos
	Msg      string
	Related  []RelatedLoc
	Source   string
}

ParseError is a parser-level error with source location.

func (e *ParseError) Error() string

func (e *ParseError) PrettyError() string

type Pos ¶

type Pos struct {
	Offset int
	Line   int
}

Pos is a byte-based position in the source. Line is 1-based.

Column is intentionally NOT stored: it is needed only on the cold error path, so carrying it in every token (and recomputing it on every advance) is pure overhead. Compute it on demand with ColumnIn, which derives it from Offset and the source. Dropping the field shrinks Pos from 24 to 16 bytes, which in turn shrinks the token struct that embeds it — and the token stream is copied on every peek/advance/emit, so this directly cuts CPU.

func (p Pos) ColumnIn(src string) int

func (p Pos) String() string

type RawNode ¶

type RawNode struct {
	Text string
	Line int
}

RawNode holds verbatim source text — anything outside structured HTML or Twig syntax, plus the bytes of any Twig tag that has no registered handler.

func (r *RawNode) Dump(indent int) string

type RelatedLoc ¶

type RelatedLoc struct {
	Pos Pos
	Msg string
}

RelatedLoc points to another location relevant to a ParseError (e.g. the opening tag for an unmatched closer).

type TagParseFunc ¶

type TagParseFunc func(p *parser, openTok token) (Node, error)

TagParseFunc is the per-tag parser hook.

type TagSpec ¶

type TagSpec struct {
	// Name is the identifier after `{%` (e.g. "block", "if").
	Name string
	// EndTag is the closing tag, e.g. "endblock" for a block tag.
	// Empty string for tags with no body ("set" with `=`, "include", "extends").
	EndTag string
	// Followers are sibling tags that may appear inside the body without
	// closing it (e.g. "elseif", "else" inside "if").
	Followers []string
	// Parse turns the tag into an AST node. It is called with the cursor
	// on the OPEN token of the tag.
	Parse TagParseFunc
}

TagSpec describes how to parse a single Twig statement tag (e.g. "block", "if", "for", "include"). The registry is the entry point for adding new tag support — see tag_block.go, tag_if.go etc.

Lifecycle:

• Parse is called when the parser sees `{% Name ... %}`.
• openTok is the Twig statement OPEN token; the parser has not yet consumed the identifier or body. Parse implementations should advance the cursor past `%}` (and past any EndTag closer).

Followers and EndTag are advisory: they tell parseTagBody when to stop collecting children. A block tag is "open" if either EndTag is set or the body parser is invoked.

type TemplateExpressionNode ¶

type TemplateExpressionNode struct {
	Expression string
	Trim       TwigTrim
	Line       int
}

TemplateExpressionNode represents a `{{ ... }}` Twig expression.

func (t *TemplateExpressionNode) Dump(indent int) string

type TwigBlockNode ¶

type TwigBlockNode struct {
	Name      string
	Children  NodeList
	OpenTrim  TwigTrim
	CloseTrim TwigTrim
	Line      int
}

TwigBlockNode represents `{% block name %}...{% endblock %}`. OpenTrim is the trim flags on the `{% block name %}` delimiters; CloseTrim is the trim flags on the `{% endblock %}` delimiters.

func (t *TwigBlockNode) Dump(indent int) string

type TwigCommentNode ¶

type TwigCommentNode struct {
	Body string
	Trim TwigTrim
	Line int
}

TwigCommentNode represents a `{# ... #}` Twig comment. The body is the raw text between the delimiters, preserved verbatim (including leading and trailing whitespace).

func (c *TwigCommentNode) Dump(indent int) string

type TwigGenericBlockNode ¶

type TwigGenericBlockNode struct {
	Name      string
	Args      string // raw args body, with leading/trailing space stripped
	EndTag    string
	Body      NodeList
	Else      NodeList
	OpenTrim  TwigTrim
	ElseTrim  TwigTrim
	CloseTrim TwigTrim
	Line      int
}

TwigGenericBlockNode represents a Twig statement tag that opens a block, e.g. `{% for x in xs %}body{% endfor %}` or `{% embed 't' %}body{% endembed %}`. The body is parsed recursively as Twig+HTML content.

Else is populated when the block tag supports an `{% else %}` follower (currently just `{% for %}`); it holds the body between `{% else %}` and the block's EndTag. Else is nil/empty for tags without an else clause.

func (n *TwigGenericBlockNode) Dump(indent int) string

type TwigIfBranch ¶

type TwigIfBranch struct {
	Condition string
	Body      NodeList
	Trim      TwigTrim
}

TwigIfBranch is one conditional branch of a {% if %}...{% endif %} block. The first branch in TwigIfNode.Branches is the "if" itself; subsequent entries are "elseif" branches. The else (no-condition) branch is held separately on TwigIfNode.ElseChildren. Trim is the trim flags on the branch's own header delimiters.

type TwigIfNode ¶

type TwigIfNode struct {
	Branches     []TwigIfBranch
	ElseChildren NodeList
	// ElseTrim is the trim flags on the `{% else %}` delimiters when the
	// else clause is present.
	ElseTrim TwigTrim
	// EndTrim is the trim flags on the `{% endif %}` delimiters.
	EndTrim TwigTrim
	Line    int
}

TwigIfNode represents `{% if %}...{% elseif %}...{% else %}...{% endif %}`. Branches[0] is always the "if"; Branches[1..] are "elseif"s. ElseChildren is nil/empty when there is no {% else %} clause.

func (t *TwigIfNode) Dump(indent int) string

type TwigStandaloneTagNode ¶

type TwigStandaloneTagNode struct {
	Name string
	Args string
	Trim TwigTrim
	Line int
}

TwigStandaloneTagNode represents a Twig tag with no body, e.g. `{% include "x.twig" %}`, `{% extends "@base" %}`, `{% set x = 1 %}`, `{% sw_include "..." with {} %}`.

func (n *TwigStandaloneTagNode) Dump(indent int) string

type TwigTrim ¶

type TwigTrim struct {
	Left  bool // open delimiter has a leading '-' (e.g. {%-)
	Right bool // close delimiter has a trailing '-' (e.g. -%})
}

TwigTrim records the whitespace-control modifiers on a single Twig delimiter pair. `{%- if -%}` is TwigTrim{Left: true, Right: true} on the if-header, for example. Twig strips surrounding whitespace at render time when a side is true, so the formatter must emit `{%-`/`-%}` (or `{{-`/`-}}`, `{#-`/`-#}`) verbatim — losing them would change rendered output.

type TwigVerbatimNode ¶

type TwigVerbatimNode struct {
	Body      string
	OpenTrim  TwigTrim
	CloseTrim TwigTrim
	Line      int
}

TwigVerbatimNode represents `{% verbatim %}...{% endverbatim %}`. The body is preserved as raw text — the parser does NOT recurse into the body, since the whole point of `{% verbatim %}` is to disable Twig interpretation for its contents.

func (v *TwigVerbatimNode) Dump(indent int) string