tpl

Documentation

Overview

Package tpl contains template functions and related types.

Index

• Constants
• Variables
• func StripHTML(s string) string
• type DeferredExecution
• type FileInfo
• type Info
• type IsInternalTemplateProvider
• type ParseConfig
• type ParseInfo
  • func (info ParseInfo) IsZero() bool
• type RenderingContext
• type Template
  • func AddIdentity(t Template) Template
• type TemplateDebugger
• type TemplateExecutor
• type TemplateFinder
• type TemplateFuncGetter
• type TemplateHandler
• type TemplateHandlers
• type TemplateLookup
• type TemplateLookupVariant
• type TemplateManager
• type TemplateParseFinder
• type TemplateParser
• type TemplateVariants
• type TemplatesProvider
• type UnusedTemplatesProvider

Constants

const (
	HugoDeferredTemplatePrefix = "__hdeferred/"
	HugoDeferredTemplateSuffix = "__d="
)

const TemplateVersion = 2

Increments on breaking changes.

Variables

var Context = struct {
	DependencyManagerScopedProvider    hcontext.ContextDispatcher[identity.DependencyManagerScopedProvider]
	GetDependencyManagerInCurrentScope func(context.Context) identity.Manager
	DependencyScope                    hcontext.ContextDispatcher[int]
	Page                               hcontext.ContextDispatcher[page]
	IsInGoldmark                       hcontext.ContextDispatcher[bool]
}{
	DependencyManagerScopedProvider: hcontext.NewContextDispatcher[identity.DependencyManagerScopedProvider](contextKey("DependencyManagerScopedProvider")),
	DependencyScope:                 hcontext.NewContextDispatcher[int](contextKey("DependencyScope")),
	Page:                            hcontext.NewContextDispatcher[page](contextKey("Page")),
	IsInGoldmark:                    hcontext.NewContextDispatcher[bool](contextKey("IsInGoldmark")),
}

Context manages values passed in the context to templates.

var DefaultParseConfig = ParseConfig{
	Version: TemplateVersion,
}

var DefaultParseInfo = ParseInfo{
	Config: DefaultParseConfig,
}

Functions

func StripHTML

func StripHTML(s string) string

StripHTML strips out all HTML tags in s.

Types

type DeferredExecution

type DeferredExecution struct {
	Mu           sync.Mutex
	Ctx          context.Context
	TemplateName string
	Data         any

	Executed bool
	Result   string
}

type FileInfo

type FileInfo interface {
	Name() string
	Filename() string
}

type Info

type Info interface {
	ParseInfo() ParseInfo
}

type IsInternalTemplateProvider

type IsInternalTemplateProvider interface {
	IsInternalTemplate() bool
}

type ParseConfig

type ParseConfig struct {
	Version int
}

type ParseInfo

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

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

	// Config extracted from template.
	Config ParseConfig
}

func (ParseInfo) IsZero

func (info ParseInfo) IsZero() bool

type RenderingContext

type RenderingContext struct {
	Site       site
	SiteOutIdx int
}

type Template

type Template interface {
	Name() string
	Prepare() (*texttemplate.Template, error)
}

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

func AddIdentity

func AddIdentity(t Template) Template

AddIdentity checks if t is an identity.Identity and returns it if so. Else it wraps it in a templateIdentity using its name as the base.

type TemplateDebugger

type TemplateDebugger interface {
	Debug()
}

TemplateDebugger prints some debug info to stdout.

type TemplateExecutor

type TemplateExecutor interface {
	ExecuteWithContext(ctx context.Context, t Template, wr io.Writer, data any) error
}

type TemplateFinder

type TemplateFinder interface {
	TemplateLookup
	TemplateLookupVariant
}

TemplateFinder finds templates.

type TemplateFuncGetter

type TemplateFuncGetter interface {
	GetFunc(name string) (reflect.Value, bool)
}

TemplateFuncGetter allows to find a template func by name.

type TemplateHandler

type TemplateHandler interface {
	TemplateFinder
	TemplateExecutor
	LookupLayout(d layouts.LayoutDescriptor, f output.Format) (Template, bool, error)
	HasTemplate(name string) bool
	GetIdentity(name string) (identity.Identity, bool)
}

TemplateHandler finds and executes templates.

type TemplateHandlers

type TemplateHandlers struct {
	Tmpl    TemplateHandler
	TxtTmpl TemplateParseFinder
}

TemplateHandlers holds the templates needed by Hugo.

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)
	LookupVariants(name string) []Template
}

type TemplateManager

type TemplateManager interface {
	TemplateHandler
	TemplateFuncGetter
	AddTemplate(name, tpl string) error
}

TemplateManager manages the collection of templates.

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 TemplateVariants

type TemplateVariants struct {
	Language     string
	OutputFormat output.Format
}

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

type TemplatesProvider

type TemplatesProvider interface {
	Tmpl() TemplateHandler
	TextTmpl() TemplateParseFinder
}

TemplatesProvider as implemented by deps.Deps.

type UnusedTemplatesProvider

type UnusedTemplatesProvider interface {
	UnusedTemplates() []FileInfo
}

UnusedTemplatesProvider lists unused templates if the build is configured to track those.