Source: context.go in package html/template


package template

import (
	"fmt"
)

context describes the state an HTML parser must be in when it reaches the portion of HTML produced by evaluating a particular template node. The zero value of type context is the start context for a template that produces an HTML fragment as defined at https://www.w3.org/TR/html5/syntax.html#the-end where the context element is null.

type context struct {
	state   state
	delim   delim
	urlPart urlPart
	jsCtx   jsCtx
	attr    attr
	element element
	err     *Error
}

func (c context) String() string {
	var err error
	if c.err != nil {
		err = c.err
	}
	return fmt.Sprintf("{%v %v %v %v %v %v %v}", c.state, c.delim, c.urlPart, c.jsCtx, c.attr, c.element, err)
}

eq reports whether two contexts are equal.

func (c context) eq(d context) bool {
	return c.state == d.state &&
		c.delim == d.delim &&
		c.urlPart == d.urlPart &&
		c.jsCtx == d.jsCtx &&
		c.attr == d.attr &&
		c.element == d.element &&
		c.err == d.err
}

mangle produces an identifier that includes a suffix that distinguishes it from template names mangled with different contexts.

The mangled name for the default context is the input templateName.

	if c.state == stateText {
		return templateName
	}
	s := templateName + "$htmltemplate_" + c.state.String()
	if c.delim != delimNone {
		s += "_" + c.delim.String()
	}
	if c.urlPart != urlPartNone {
		s += "_" + c.urlPart.String()
	}
	if c.jsCtx != jsCtxRegexp {
		s += "_" + c.jsCtx.String()
	}
	if c.attr != attrNone {
		s += "_" + c.attr.String()
	}
	if c.element != elementNone {
		s += "_" + c.element.String()
	}
	return s
}

state describes a high-level HTML parser state. It bounds the top of the element stack, and by extension the HTML insertion mode, but also contains state that does not correspond to anything in the HTML5 parsing algorithm because a single token production in the HTML grammar may contain embedded actions in a template. For instance, the quoted HTML attribute produced by <div title="Hello {{.World}}"> is a single token in HTML's grammar but in a template spans several nodes.

type state uint8

go:generate stringer -type state

stateText is parsed character data. An HTML parser is in this state when its parse position is outside an HTML tag, directive, comment, and special element body.

stateTag occurs before an HTML attribute or the end of a tag.

stateAttrName occurs inside an attribute name. It occurs between the ^'s in ` ^name^ = value`.

stateAfterName occurs after an attr name has ended but before any equals sign. It occurs between the ^'s in ` name^ ^= value`.

stateBeforeValue occurs after the equals sign but before the value. It occurs between the ^'s in ` name =^ ^value`.

stateHTMLCmt occurs inside an .

stateRCDATA occurs inside an RCDATA element (<textarea> or <title>) as described at https://www.w3.org/TR/html5/syntax.html#elements-0

stateAttr occurs inside an HTML attribute whose content is text.

stateURL occurs inside an HTML attribute whose content is a URL.

stateSrcset occurs inside an HTML srcset attribute.

stateJS occurs inside an event handler or script element.

stateJSDqStr occurs inside a JavaScript double quoted string.

stateJSSqStr occurs inside a JavaScript single quoted string.

stateJSRegexp occurs inside a JavaScript regexp literal.

stateJSBlockCmt occurs inside a JavaScript block comment .

stateJSLineCmt occurs inside a JavaScript // line comment.

stateCSS occurs inside a <style> element or style attribute.

stateCSSDqStr occurs inside a CSS double quoted string.

stateCSSSqStr occurs inside a CSS single quoted string.

stateCSSDqURL occurs inside a CSS double quoted url("...").

stateCSSSqURL occurs inside a CSS single quoted url('...').

stateCSSURL occurs inside a CSS unquoted url(...).

stateCSSBlockCmt occurs inside a CSS block comment .

stateCSSLineCmt occurs inside a CSS // line comment.

stateError is an infectious error state outside any valid HTML/CSS/JS construct.

	stateError
)

isComment is true for any state that contains content meant for template authors & maintainers, not for end-users or machines.

func isComment(s state) bool {
	switch s {
	case stateHTMLCmt, stateJSBlockCmt, stateJSLineCmt, stateCSSBlockCmt, stateCSSLineCmt:
		return true
	}
	return false
}

isInTag return whether s occurs solely inside an HTML tag.

func isInTag(s state) bool {
	switch s {
	case stateTag, stateAttrName, stateAfterName, stateBeforeValue, stateAttr:
		return true
	}
	return false
}

delim is the delimiter that will end the current HTML attribute.

type delim uint8

go:generate stringer -type delim

delimNone occurs outside any attribute.

delimDoubleQuote occurs when a double quote (") closes the attribute.

delimSingleQuote occurs when a single quote (') closes the attribute.

delimSpaceOrTagEnd occurs when a space or right angle bracket (>) closes the attribute.

	delimSpaceOrTagEnd
)

urlPart identifies a part in an RFC 3986 hierarchical URL to allow different encoding strategies.

type urlPart uint8

go:generate stringer -type urlPart

urlPartNone occurs when not in a URL, or possibly at the start: ^ in "^http://auth/path?k=v#frag".

urlPartPreQuery occurs in the scheme, authority, or path; between the ^s in "h^ttp://auth/path^?k=v#frag".

urlPartQueryOrFrag occurs in the query portion between the ^s in "http://auth/path?^k=v#frag^".

urlPartUnknown occurs due to joining of contexts both before and after the query separator.

	urlPartUnknown
)

jsCtx determines whether a '/' starts a regular expression literal or a division operator.

type jsCtx uint8

go:generate stringer -type jsCtx

jsCtxRegexp occurs where a '/' would start a regexp literal.

jsCtxDivOp occurs where a '/' would start a division operator.

jsCtxUnknown occurs where a '/' is ambiguous due to context joining.

	jsCtxUnknown
)

element identifies the HTML element when inside a start tag or special body. Certain HTML element (for example <script> and <style>) have bodies that are treated differently from stateText so the element type is necessary to transition into the correct context at the end of a tag and to identify the end delimiter for the body.

type element uint8

go:generate stringer -type element

elementNone occurs outside a special tag or special element body.

elementScript corresponds to the raw text <script> element with JS MIME type or no type attribute.

elementStyle corresponds to the raw text <style> element.

elementTextarea corresponds to the RCDATA <textarea> element.

elementTitle corresponds to the RCDATA <title> element.

	elementTitle
)

go:generate stringer -type attr

attr identifies the current HTML attribute when inside the attribute, that is, starting from stateAttrName until stateTag/stateText (exclusive).

type attr uint8

attrNone corresponds to a normal attribute or no attribute.

attrScript corresponds to an event handler attribute.

attrScriptType corresponds to the type attribute in script HTML element

attrStyle corresponds to the style attribute whose value is CSS.

attrURL corresponds to an attribute whose value is a URL.

attrSrcset corresponds to a srcset attribute.

	attrSrcset