package tpl

import "github.com/gohugoio/hugo/tpl"

Index ¶

• Constants
• Variables
• type Config
• type Info
• func (info Info) IsZero() bool
• type Template
• type TemplateAdapter
• func (t *TemplateAdapter) Execute(w io.Writer, data interface{}) (execErr error)
• func (t *TemplateAdapter) ExecuteToString(data interface{}) (string, error)
• func (t *TemplateAdapter) TemplateInfo() Info
• func (t *TemplateAdapter) Tree() string
• type TemplateDebugger
• type TemplateExecutor
• type TemplateFinder
• type TemplateFuncsGetter
• type TemplateHandler
• type TemplateInfoProvider
• type TemplateLookup
• type TemplateLookupVariant
• type TemplateParseFinder
• type TemplateParser
• type TemplateTestMocker
• type TemplateVariants

Constants ¶

const TemplateVersion = 2

Increments on breaking changes.

Variables ¶

var DefaultConfig = Config{
	Version: TemplateVersion,
}

Types ¶

type Config ¶

type Config struct {
	Version int
}

type Info ¶

type Info struct {

	// Set for shortcode templates with any {{ .Inner }}
	IsInner bool

	// Set for partials with a return statement.
	HasReturn bool

	// Config extracted from template.
	Config Config
}

Info holds some info extracted from a parsed template.

func (Info) IsZero ¶

func (info Info) IsZero() bool

type Template ¶

type Template interface {
	Execute(wr io.Writer, data interface{}) error
	Name() string
}

Template is the common interface between text/template and html/template.

type TemplateAdapter ¶

type TemplateAdapter struct {
	Template
	Metrics metrics.Provider

	Info Info

	// The filesystem where the templates are stored.
	Fs afero.Fs

	// Maps to base template if relevant.
	NameBaseTemplateName map[string]string
}

TemplateAdapter implements the TemplateExecutor interface.

func (*TemplateAdapter) Execute ¶

func (t *TemplateAdapter) Execute(w io.Writer, data interface{}) (execErr error)

Execute executes the current template. The actual execution is performed by the embedded text or html template, but we add an implementation here so we can add a timer for some metrics.

func (*TemplateAdapter) ExecuteToString ¶

func (t *TemplateAdapter) ExecuteToString(data interface{}) (string, error)

ExecuteToString executes the current template and returns the result as a string.

func (*TemplateAdapter) TemplateInfo ¶

func (t *TemplateAdapter) TemplateInfo() Info

func (*TemplateAdapter) Tree ¶

func (t *TemplateAdapter) Tree() string

Tree returns the template Parse tree as a string. Note: this isn't safe for parallel execution on the same template vs Lookup and Execute.

type TemplateDebugger ¶

type TemplateDebugger interface {
	Debug()
}

TemplateDebugger prints some debug info to stdoud.

type TemplateExecutor ¶

type TemplateExecutor interface {
	Template
	ExecuteToString(data interface{}) (string, error)
	Tree() string
}

TemplateExecutor adds some extras to Template.

type TemplateFinder ¶

type TemplateFinder interface {
	TemplateLookup
	TemplateLookupVariant
}

TemplateFinder finds templates.

type TemplateFuncsGetter ¶

type TemplateFuncsGetter interface {
	GetFuncs() map[string]interface{}
}

TemplateFuncsGetter allows to get a map of functions.

type TemplateHandler ¶

type TemplateHandler interface {
	TemplateFinder
	AddTemplate(name, tpl string) error
	AddLateTemplate(name, tpl string) error
	LoadTemplates(prefix string) error

	NewTextTemplate() TemplateParseFinder

	MarkReady() error
	RebuildClone()
}

TemplateHandler manages the collection of templates.

type TemplateInfoProvider ¶

type TemplateInfoProvider interface {
	TemplateInfo() Info
}

TemplateInfoProvider provides some contextual information about a template.

type TemplateLookup ¶

type TemplateLookup interface {
	Lookup(name string) (Template, bool)
}

type TemplateLookupVariant ¶

type TemplateLookupVariant interface {
	// TODO(bep) this currently only works for shortcodes.
	// We may unify and expand this variant pattern to the
	// other templates, but we need this now for the shortcodes to
	// quickly determine if a shortcode has a template for a given
	// output format.
	// It returns the template, if it was found or not and if there are
	// alternative representations (output format, language).
	// We are currently only interested in output formats, so we should improve
	// this for speed.
	LookupVariant(name string, variants TemplateVariants) (Template, bool, bool)
}

type TemplateParseFinder ¶

type TemplateParseFinder interface {
	TemplateParser
	TemplateFinder
}

TemplateParseFinder provides both parsing and finding.

type TemplateParser ¶

type TemplateParser interface {
	Parse(name, tpl string) (Template, error)
}

TemplateParser is used to parse ad-hoc templates, e.g. in the Resource chain.

type TemplateTestMocker ¶

type TemplateTestMocker interface {
	SetFuncs(funcMap map[string]interface{})
}

TemplateTestMocker adds a way to override some template funcs during tests. The interface is named so it's not used in regular application code.

type TemplateVariants ¶

type TemplateVariants struct {
	Language     string
	OutputFormat output.Format
}

TemplateVariants describes the possible variants of a template. All of these may be empty.

Source Files ¶

template.go template_info.go

Directories ¶