texttemplate

Documentation

Index

• Constants
• Variables
• type ExecError
  • func (e ExecError) Error() string
• type ExecHelper
• type Executer
  • func NewExecuter(helper ExecHelper) Executer
• type FuncMap
• type Preparer
• type Template
  • func Must(t *Template, err error) *Template
  • func New(name string) *Template
  • func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error)
  • func (t *Template) Clone() (*Template, error)
  • func (t *Template) Funcs(funcMap FuncMap) *Template
  • func (t *Template) Lookup(name string) *Template
  • func (t *Template) Name() string
  • func (t *Template) New(name string) *Template
  • func (t *Template) Parse(text string) (*Template, error)
  • func (t *Template) Prepare() (*Template, error)
  • func (t *Template) Templates() []*Template

Constants

const (
	// DataContextKey The data object passed to Execute or ExecuteWithContext gets stored with this key if not already set.
	DataContextKey = dataContextKeyType("data")
)

Variables

var GoFuncs = builtinFuncs()

Export it so we can populate Hugo's func map with it, which makes it faster.

Types

type ExecError

type ExecError struct {
	Name string // Name of template.
	Err  error  // Pre-formatted error.
}

func (ExecError) Error

func (e ExecError) Error() string

type ExecHelper

type ExecHelper interface {
	Init(ctx context.Context, tmpl Preparer)
	GetFunc(ctx context.Context, tmpl Preparer, name string) (reflect.Value, reflect.Value, bool)
	GetMethod(ctx context.Context, tmpl Preparer, receiver reflect.Value, name string) (method reflect.Value, firstArg reflect.Value)
	GetMapValue(ctx context.Context, tmpl Preparer, receiver, key reflect.Value) (reflect.Value, bool)
}

ExecHelper allows some custom eval hooks.

type Executer

type Executer interface {
	ExecuteWithContext(ctx context.Context, p Preparer, wr io.Writer, data any) error
}

Executer executes a given template.

func NewExecuter

func NewExecuter(helper ExecHelper) Executer

type FuncMap

type FuncMap map[string]any

type Preparer

type Preparer interface {
	Prepare() (*Template, error)
}

Preparer prepares the template before execution.

type Template

type Template struct {
	*parse.Tree
	// contains filtered or unexported fields
}

Template is the representation of a parsed template. The *parse.Tree field is exported only for use by html/template and should be treated as unexported by all other clients.

func Must

func Must(t *Template, err error) *Template

Must is a helper that wraps a call to a function returning (*Template, error) and panics if the error is non-nil. It is intended for use in variable initializations such as

var t = template.Must(template.New("name").Parse("text"))

func New

func New(name string) *Template

New allocates a new, undefined template with the given name.

func (*Template) AddParseTree

func (t *Template) AddParseTree(name string, tree *parse.Tree) (*Template, error)

AddParseTree associates the argument parse tree with the template t, giving it the specified name. If the template has not been defined, this tree becomes its definition. If it has been defined and already has that name, the existing definition is replaced; otherwise a new template is created, defined, and returned.

func (*Template) Clone

func (t *Template) Clone() (*Template, error)

Clone returns a duplicate of the template, including all associated templates. The actual representation is not copied, but the name space of associated templates is, so further calls to Parse in the copy will add templates to the copy but not to the original. Clone can be used to prepare common templates and use them with variant definitions for other templates by adding the variants after the clone is made.

func (*Template) Funcs

func (t *Template) Funcs(funcMap FuncMap) *Template

Funcs adds the elements of the argument map to the template's function map. It must be called before the template is parsed. It panics if a value in the map is not a function with appropriate return type or if the name cannot be used syntactically as a function in a template. It is legal to overwrite elements of the map. The return value is the template, so calls can be chained.

func (*Template) Lookup

func (t *Template) Lookup(name string) *Template

Lookup returns the template with the given name that is associated with t. It returns nil if there is no such template or the template has no definition.

func (*Template) Name

func (t *Template) Name() string

Name returns the name of the template.

func (*Template) New

func (t *Template) New(name string) *Template

New allocates a new, undefined template associated with the given one and with the same delimiters. The association, which is transitive, allows one template to invoke another with a {{template}} action.

Because associated templates share underlying data, template construction cannot be done safely in parallel. Once the templates are constructed, they can be executed in parallel.

func (*Template) Parse

func (t *Template) Parse(text string) (*Template, error)

Parse parses text as a template body for t. Named template definitions ({{define ...}} or {{block ...}} statements) in text define additional templates associated with t and are removed from the definition of t itself.

Templates can be redefined in successive calls to Parse. A template definition with a body containing only white space and comments is considered empty and will not replace an existing template's body. This allows using Parse to add new named template definitions without overwriting the main template body.

func (*Template) Prepare

func (t *Template) Prepare() (*Template, error)

Prepare returns a template ready for execution.

func (*Template) Templates

func (t *Template) Templates() []*Template

Templates returns a slice of defined templates associated with t.