src/html/template/context.go - go - Git at Google

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 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
 // http://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 {
 	return fmt.Sprintf("{%v %v %v %v %v %v %v}", c.state, c.delim, c.urlPart, c.jsCtx, c.attr, c.element, c.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.
 func (c context) mangle(templateName string) string {
 	// 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 != 0 {
 		s += "_" + c.delim.String()
 	}
 	if c.urlPart != 0 {
 		s += "_" + c.urlPart.String()
 	}
 	if c.jsCtx != 0 {
 		s += "_" + c.jsCtx.String()
 	}
 	if c.attr != 0 {
 		s += "_" + c.attr.String()
 	}
 	if c.element != 0 {
 		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

 const (
 	// 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.
 	stateText state = iota
 	// stateTag occurs before an HTML attribute or the end of a tag.
 	stateTag
 	// stateAttrName occurs inside an attribute name.
 	// It occurs between the ^'s in ` ^name^ = value`.
 	stateAttrName
 	// stateAfterName occurs after an attr name has ended but before any
 	// equals sign. It occurs between the ^'s in ` name^ ^= value`.
 	stateAfterName
 	// stateBeforeValue occurs after the equals sign but before the value.
 	// It occurs between the ^'s in ` name =^ ^value`.
 	stateBeforeValue
 	// stateHTMLCmt occurs inside an <!-- HTML comment -->.
 	stateHTMLCmt
 	// stateRCDATA occurs inside an RCDATA element (<textarea> or <title>)
 	// as described at http://www.w3.org/TR/html5/syntax.html#elements-0
 	stateRCDATA
 	// stateAttr occurs inside an HTML attribute whose content is text.
 	stateAttr
 	// stateURL occurs inside an HTML attribute whose content is a URL.
 	stateURL
 	// stateSrcset occurs inside an HTML srcset attribute.
 	stateSrcset
 	// stateJS occurs inside an event handler or script element.
 	stateJS
 	// stateJSDqStr occurs inside a JavaScript double quoted string.
 	stateJSDqStr
 	// stateJSSqStr occurs inside a JavaScript single quoted string.
 	stateJSSqStr
 	// stateJSRegexp occurs inside a JavaScript regexp literal.
 	stateJSRegexp
 	// stateJSBlockCmt occurs inside a JavaScript /* block comment */.
 	stateJSBlockCmt
 	// stateJSLineCmt occurs inside a JavaScript // line comment.
 	stateJSLineCmt
 	// stateCSS occurs inside a <style> element or style attribute.
 	stateCSS
 	// stateCSSDqStr occurs inside a CSS double quoted string.
 	stateCSSDqStr
 	// stateCSSSqStr occurs inside a CSS single quoted string.
 	stateCSSSqStr
 	// stateCSSDqURL occurs inside a CSS double quoted url("...").
 	stateCSSDqURL
 	// stateCSSSqURL occurs inside a CSS single quoted url('...').
 	stateCSSSqURL
 	// stateCSSURL occurs inside a CSS unquoted url(...).
 	stateCSSURL
 	// stateCSSBlockCmt occurs inside a CSS /* block comment */.
 	stateCSSBlockCmt
 	// stateCSSLineCmt occurs inside a CSS // line comment.
 	stateCSSLineCmt
 	// stateError is an infectious error state outside any valid
 	// HTML/CSS/JS construct.
 	stateError
 )

 var stateNames = [...]string{
 	stateText:        "stateText",
 	stateTag:         "stateTag",
 	stateAttrName:    "stateAttrName",
 	stateAfterName:   "stateAfterName",
 	stateBeforeValue: "stateBeforeValue",
 	stateHTMLCmt:     "stateHTMLCmt",
 	stateRCDATA:      "stateRCDATA",
 	stateAttr:        "stateAttr",
 	stateURL:         "stateURL",
 	stateSrcset:      "stateSrcset",
 	stateJS:          "stateJS",
 	stateJSDqStr:     "stateJSDqStr",
 	stateJSSqStr:     "stateJSSqStr",
 	stateJSRegexp:    "stateJSRegexp",
 	stateJSBlockCmt:  "stateJSBlockCmt",
 	stateJSLineCmt:   "stateJSLineCmt",
 	stateCSS:         "stateCSS",
 	stateCSSDqStr:    "stateCSSDqStr",
 	stateCSSSqStr:    "stateCSSSqStr",
 	stateCSSDqURL:    "stateCSSDqURL",
 	stateCSSSqURL:    "stateCSSSqURL",
 	stateCSSURL:      "stateCSSURL",
 	stateCSSBlockCmt: "stateCSSBlockCmt",
 	stateCSSLineCmt:  "stateCSSLineCmt",
 	stateError:       "stateError",
 }

 func (s state) String() string {
 	if int(s) < len(stateNames) {
 		return stateNames[s]
 	}
 	return fmt.Sprintf("illegal state %d", int(s))
 }

 // 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

 const (
 	// delimNone occurs outside any attribute.
 	delimNone delim = iota
 	// delimDoubleQuote occurs when a double quote (") closes the attribute.
 	delimDoubleQuote
 	// delimSingleQuote occurs when a single quote (') closes the attribute.
 	delimSingleQuote
 	// delimSpaceOrTagEnd occurs when a space or right angle bracket (>)
 	// closes the attribute.
 	delimSpaceOrTagEnd
 )

 var delimNames = [...]string{
 	delimNone:          "delimNone",
 	delimDoubleQuote:   "delimDoubleQuote",
 	delimSingleQuote:   "delimSingleQuote",
 	delimSpaceOrTagEnd: "delimSpaceOrTagEnd",
 }

 func (d delim) String() string {
 	if int(d) < len(delimNames) {
 		return delimNames[d]
 	}
 	return fmt.Sprintf("illegal delim %d", int(d))
 }

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

 const (
 	// urlPartNone occurs when not in a URL, or possibly at the start:
 	// ^ in "^http://auth/path?k=v#frag".
 	urlPartNone urlPart = iota
 	// urlPartPreQuery occurs in the scheme, authority, or path; between the
 	// ^s in "h^ttp://auth/path^?k=v#frag".
 	urlPartPreQuery
 	// urlPartQueryOrFrag occurs in the query portion between the ^s in
 	// "http://auth/path?^k=v#frag^".
 	urlPartQueryOrFrag
 	// urlPartUnknown occurs due to joining of contexts both before and
 	// after the query separator.
 	urlPartUnknown
 )

 var urlPartNames = [...]string{
 	urlPartNone:        "urlPartNone",
 	urlPartPreQuery:    "urlPartPreQuery",
 	urlPartQueryOrFrag: "urlPartQueryOrFrag",
 	urlPartUnknown:     "urlPartUnknown",
 }

 func (u urlPart) String() string {
 	if int(u) < len(urlPartNames) {
 		return urlPartNames[u]
 	}
 	return fmt.Sprintf("illegal urlPart %d", int(u))
 }

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

 const (
 	// jsCtxRegexp occurs where a '/' would start a regexp literal.
 	jsCtxRegexp jsCtx = iota
 	// jsCtxDivOp occurs where a '/' would start a division operator.
 	jsCtxDivOp
 	// jsCtxUnknown occurs where a '/' is ambiguous due to context joining.
 	jsCtxUnknown
 )

 func (c jsCtx) String() string {
 	switch c {
 	case jsCtxRegexp:
 		return "jsCtxRegexp"
 	case jsCtxDivOp:
 		return "jsCtxDivOp"
 	case jsCtxUnknown:
 		return "jsCtxUnknown"
 	}
 	return fmt.Sprintf("illegal jsCtx %d", int(c))
 }

 // 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

 const (
 	// elementNone occurs outside a special tag or special element body.
 	elementNone element = iota
 	// elementScript corresponds to the raw text <script> element
 	// with JS MIME type or no type attribute.
 	elementScript
 	// elementStyle corresponds to the raw text <style> element.
 	elementStyle
 	// elementTextarea corresponds to the RCDATA <textarea> element.
 	elementTextarea
 	// elementTitle corresponds to the RCDATA <title> element.
 	elementTitle
 )

 var elementNames = [...]string{
 	elementNone:     "elementNone",
 	elementScript:   "elementScript",
 	elementStyle:    "elementStyle",
 	elementTextarea: "elementTextarea",
 	elementTitle:    "elementTitle",
 }

 func (e element) String() string {
 	if int(e) < len(elementNames) {
 		return elementNames[e]
 	}
 	return fmt.Sprintf("illegal element %d", int(e))
 }

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

 const (
 	// attrNone corresponds to a normal attribute or no attribute.
 	attrNone attr = iota
 	// attrScript corresponds to an event handler attribute.
 	attrScript
 	// attrScriptType corresponds to the type attribute in script HTML element
 	attrScriptType
 	// attrStyle corresponds to the style attribute whose value is CSS.
 	attrStyle
 	// attrURL corresponds to an attribute whose value is a URL.
 	attrURL
 	// attrSrcset corresponds to a srcset attribute.
 	attrSrcset
 )

 var attrNames = [...]string{
 	attrNone:       "attrNone",
 	attrScript:     "attrScript",
 	attrScriptType: "attrScriptType",
 	attrStyle:      "attrStyle",
 	attrURL:        "attrURL",
 	attrSrcset:     "attrSrcset",
 }

 func (a attr) String() string {
 	if int(a) < len(attrNames) {
 		return attrNames[a]
 	}
 	return fmt.Sprintf("illegal attr %d", int(a))
 }
	// Copyright 2011 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	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
	// http://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 {
	return fmt.Sprintf("{%v %v %v %v %v %v %v}", c.state, c.delim, c.urlPart, c.jsCtx, c.attr, c.element, c.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.
	func (c context) mangle(templateName string) string {
	// 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 != 0 {
	s += "_" + c.delim.String()
	}
	if c.urlPart != 0 {
	s += "_" + c.urlPart.String()
	}
	if c.jsCtx != 0 {
	s += "_" + c.jsCtx.String()
	}
	if c.attr != 0 {
	s += "_" + c.attr.String()
	}
	if c.element != 0 {
	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

	const (
	// 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.
	stateText state = iota
	// stateTag occurs before an HTML attribute or the end of a tag.
	stateTag
	// stateAttrName occurs inside an attribute name.
	// It occurs between the ^'s in ` ^name^ = value`.
	stateAttrName
	// stateAfterName occurs after an attr name has ended but before any
	// equals sign. It occurs between the ^'s in ` name^ ^= value`.
	stateAfterName
	// stateBeforeValue occurs after the equals sign but before the value.
	// It occurs between the ^'s in ` name =^ ^value`.
	stateBeforeValue
	// stateHTMLCmt occurs inside an <!-- HTML comment -->.
	stateHTMLCmt
	// stateRCDATA occurs inside an RCDATA element (<textarea> or <title>)
	// as described at http://www.w3.org/TR/html5/syntax.html#elements-0
	stateRCDATA
	// stateAttr occurs inside an HTML attribute whose content is text.
	stateAttr
	// stateURL occurs inside an HTML attribute whose content is a URL.
	stateURL
	// stateSrcset occurs inside an HTML srcset attribute.
	stateSrcset
	// stateJS occurs inside an event handler or script element.
	stateJS
	// stateJSDqStr occurs inside a JavaScript double quoted string.
	stateJSDqStr
	// stateJSSqStr occurs inside a JavaScript single quoted string.
	stateJSSqStr
	// stateJSRegexp occurs inside a JavaScript regexp literal.
	stateJSRegexp
	// stateJSBlockCmt occurs inside a JavaScript /* block comment */.
	stateJSBlockCmt
	// stateJSLineCmt occurs inside a JavaScript // line comment.
	stateJSLineCmt
	// stateCSS occurs inside a <style> element or style attribute.
	stateCSS
	// stateCSSDqStr occurs inside a CSS double quoted string.
	stateCSSDqStr
	// stateCSSSqStr occurs inside a CSS single quoted string.
	stateCSSSqStr
	// stateCSSDqURL occurs inside a CSS double quoted url("...").
	stateCSSDqURL
	// stateCSSSqURL occurs inside a CSS single quoted url('...').
	stateCSSSqURL
	// stateCSSURL occurs inside a CSS unquoted url(...).
	stateCSSURL
	// stateCSSBlockCmt occurs inside a CSS /* block comment */.
	stateCSSBlockCmt
	// stateCSSLineCmt occurs inside a CSS // line comment.
	stateCSSLineCmt
	// stateError is an infectious error state outside any valid
	// HTML/CSS/JS construct.
	stateError
	)

	var stateNames = [...]string{
	stateText: "stateText",
	stateTag: "stateTag",
	stateAttrName: "stateAttrName",
	stateAfterName: "stateAfterName",
	stateBeforeValue: "stateBeforeValue",
	stateHTMLCmt: "stateHTMLCmt",
	stateRCDATA: "stateRCDATA",
	stateAttr: "stateAttr",
	stateURL: "stateURL",
	stateSrcset: "stateSrcset",
	stateJS: "stateJS",
	stateJSDqStr: "stateJSDqStr",
	stateJSSqStr: "stateJSSqStr",
	stateJSRegexp: "stateJSRegexp",
	stateJSBlockCmt: "stateJSBlockCmt",
	stateJSLineCmt: "stateJSLineCmt",
	stateCSS: "stateCSS",
	stateCSSDqStr: "stateCSSDqStr",
	stateCSSSqStr: "stateCSSSqStr",
	stateCSSDqURL: "stateCSSDqURL",
	stateCSSSqURL: "stateCSSSqURL",
	stateCSSURL: "stateCSSURL",
	stateCSSBlockCmt: "stateCSSBlockCmt",
	stateCSSLineCmt: "stateCSSLineCmt",
	stateError: "stateError",
	}

	func (s state) String() string {
	if int(s) < len(stateNames) {
	return stateNames[s]
	}
	return fmt.Sprintf("illegal state %d", int(s))
	}

	// 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

	const (
	// delimNone occurs outside any attribute.
	delimNone delim = iota
	// delimDoubleQuote occurs when a double quote (") closes the attribute.
	delimDoubleQuote
	// delimSingleQuote occurs when a single quote (') closes the attribute.
	delimSingleQuote
	// delimSpaceOrTagEnd occurs when a space or right angle bracket (>)
	// closes the attribute.
	delimSpaceOrTagEnd
	)

	var delimNames = [...]string{
	delimNone: "delimNone",
	delimDoubleQuote: "delimDoubleQuote",
	delimSingleQuote: "delimSingleQuote",
	delimSpaceOrTagEnd: "delimSpaceOrTagEnd",
	}

	func (d delim) String() string {
	if int(d) < len(delimNames) {
	return delimNames[d]
	}
	return fmt.Sprintf("illegal delim %d", int(d))
	}

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

	const (
	// urlPartNone occurs when not in a URL, or possibly at the start:
	// ^ in "^http://auth/path?k=v#frag".
	urlPartNone urlPart = iota
	// urlPartPreQuery occurs in the scheme, authority, or path; between the
	// ^s in "h^ttp://auth/path^?k=v#frag".
	urlPartPreQuery
	// urlPartQueryOrFrag occurs in the query portion between the ^s in
	// "http://auth/path?^k=v#frag^".
	urlPartQueryOrFrag
	// urlPartUnknown occurs due to joining of contexts both before and
	// after the query separator.
	urlPartUnknown
	)

	var urlPartNames = [...]string{
	urlPartNone: "urlPartNone",
	urlPartPreQuery: "urlPartPreQuery",
	urlPartQueryOrFrag: "urlPartQueryOrFrag",
	urlPartUnknown: "urlPartUnknown",
	}

	func (u urlPart) String() string {
	if int(u) < len(urlPartNames) {
	return urlPartNames[u]
	}
	return fmt.Sprintf("illegal urlPart %d", int(u))
	}

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

	const (
	// jsCtxRegexp occurs where a '/' would start a regexp literal.
	jsCtxRegexp jsCtx = iota
	// jsCtxDivOp occurs where a '/' would start a division operator.
	jsCtxDivOp
	// jsCtxUnknown occurs where a '/' is ambiguous due to context joining.
	jsCtxUnknown
	)

	func (c jsCtx) String() string {
	switch c {
	case jsCtxRegexp:
	return "jsCtxRegexp"
	case jsCtxDivOp:
	return "jsCtxDivOp"
	case jsCtxUnknown:
	return "jsCtxUnknown"
	}
	return fmt.Sprintf("illegal jsCtx %d", int(c))
	}

	// 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

	const (
	// elementNone occurs outside a special tag or special element body.
	elementNone element = iota
	// elementScript corresponds to the raw text <script> element
	// with JS MIME type or no type attribute.
	elementScript
	// elementStyle corresponds to the raw text <style> element.
	elementStyle
	// elementTextarea corresponds to the RCDATA <textarea> element.
	elementTextarea
	// elementTitle corresponds to the RCDATA <title> element.
	elementTitle
	)

	var elementNames = [...]string{
	elementNone: "elementNone",
	elementScript: "elementScript",
	elementStyle: "elementStyle",
	elementTextarea: "elementTextarea",
	elementTitle: "elementTitle",
	}

	func (e element) String() string {
	if int(e) < len(elementNames) {
	return elementNames[e]
	}
	return fmt.Sprintf("illegal element %d", int(e))
	}

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

	const (
	// attrNone corresponds to a normal attribute or no attribute.
	attrNone attr = iota
	// attrScript corresponds to an event handler attribute.
	attrScript
	// attrScriptType corresponds to the type attribute in script HTML element
	attrScriptType
	// attrStyle corresponds to the style attribute whose value is CSS.
	attrStyle
	// attrURL corresponds to an attribute whose value is a URL.
	attrURL
	// attrSrcset corresponds to a srcset attribute.
	attrSrcset
	)

	var attrNames = [...]string{
	attrNone: "attrNone",
	attrScript: "attrScript",
	attrScriptType: "attrScriptType",
	attrStyle: "attrStyle",
	attrURL: "attrURL",
	attrSrcset: "attrSrcset",
	}

	func (a attr) String() string {
	if int(a) < len(attrNames) {
	return attrNames[a]
	}
	return fmt.Sprintf("illegal attr %d", int(a))
	}