render

type BaseDirectoryReader struct {
	Path string
}

type BasicLogRenderer struct {
	// contains filtered or unexported fields
}

type CachingReader struct {
	// contains filtered or unexported fields
}

type ContextRenderer interface {
	// CloseNotifier closes any resources associated with the renderer. This is
	// especially important for renderers that use inotify internally to monitor
	// for changes.
	CloseNotifier() error

	// Context adds a new value to the context.
	Context(key string, value interface{})

	// ContextFunc adds a new function to the context.
	ContextFunc(key string, value interface{})

	// Render this context with the specified values.
	Render(name string, values interface{}, writer io.Writer) error
}

type ExtendedLogRenderer struct {
	// contains filtered or unexported fields
}

type FilesystemReader struct {
	Path string
}

type InheritanceLoader struct{}

type MapValues = pongo2.Context

type MultiRender struct {
	Default   Renderer
	Templates map[string]Renderer
}

type MultiRenderer interface {
	// AddBackend adds a renderer with the name `name` to this instance.
	AddBackend(name string, renderer Renderer)

	// Backend changes the renderer backend to one registered by the template
	// manager.
	Backend(name string) Renderer
}

type NoopMultiRenderer struct {
	NoopRenderer
}

type NoopRenderer struct{}

type NotifyLoader interface {
	Watch(func())
	CloseWatches() error
}

type Options struct {
	// MonitorChanges to the template directory and clear any internal caches
	// when a source file is modified, added, or removed.
	MonitorChanges bool

	// TemplateRoot to use for the base path. Any files above this path will be
	// inaccessible to the renderer.
	TemplateRoot string

	// Path to theme. Themes are isolated template directories that do not
	// interact with each other but share a common TemplateRoot.
	ThemePath string

	// VFS, if set, will configure the target backend with the specified virtual
	// file system.
	VFS vfs.VFS
}

type Pongo2ContextRenderer struct {
	// contains filtered or unexported fields
}

type Pongo2Renderer struct {
	// contains filtered or unexported fields
}

type PongoOptions struct {
	ProhibitedFilters []string
	ProhibitedTags    []string
	TrimBlocks        bool
	LStripBlocks      bool
	Debug             bool
	GlobalContext     pongo2.Context
	Loaders           []pongo2.TemplateLoader
	Logger            *logging.Log

	// DisableReload when templates change. Uses fsnotify to detect changes.
	// This should be set to true in production mode.
	DisableReload bool
}

type PongoVFSInheritanceLoader struct {
	// contains filtered or unexported fields
}

type PongoVFSLoader struct {
	// contains filtered or unexported fields
}

type Renderer interface {
	// CloseNotifier closes any inotify resources associated with the Renderer.
	// If the Renderer doesn't implement inotify, this should be a noop. Some
	// Capstan templates may use fsnotifier internally, and this should be
	// called before re-exec'ing the process, e.g. via routing.Relaunch().
	CloseNotifier() error

	// CompileDir compiles all templates in the specified path. Not all Renderer
	// implementations may support this; those that don't will implement this as
	// a noop.
	CompileDir(path string) error

	// GlobalContext adds a value to the global context for a given template.
	// Not all backends support context assignment.
	GlobalContext(key string, value interface{})

	// Render the template specified by name using the data `values` as its
	// source. Depending on the backend, `name` may reference a file name or any
	// other symbolic name the Renderer recognizes as valid. The content of
	// `values` may be a struct or map, depending on the backend; for Go
	// templates, any struct value can be provided. For pongo2 and others, this
	// must be a map.
	//
	// Implementations that don't natively return errors will attempt to map the
	// underlying template library's behavior to a sensible error. Errors may be
	// wrapped.
	Render(name string, values interface{}, writer io.Writer) error

	// ContextRenderer returns a Renderer that may be used to configure
	// additional context, such as request context(s).
	ContextRenderer() ContextRenderer

	// SetFunc is used to set the value of a function for use within the
	// template. Typically used for setting global functions like URLFor, this
	// provides a proxy for the route constructor to assign Capstan-specific
	// calls.
	//
	// Some backends may implement this as a wrapper around GlobalContext.
	SetFunc(name string, value interface{})

	// SetLogger to the specified logger instance. If unset, the renderer will
	// create its own root logger.
	SetLogger(*logging.Log)
}

type TemplateReader interface {
	// ListTemplates in a give `path` matching the pattern `glob`.
	ListTemplates(path, glob string) ([]string, error)

	// ReadTemplate accepts a name argument and returns a ReadCloser that
	// produces template data.
	ReadTemplate(name string) (io.ReadCloser, error)
}

type TextRenderer interface {
	// RenderStream operates similarly to Render() with the exception that it
	// forgoes rendering sources from the file system and instead renders a
	// template passed in via a readable stream.
	RenderStream(reader io.Reader, values interface{}, writer io.Writer) error

	// RenderText operates similarly to Render() with the exception that it
	// forgoes rendering sources from the file system and instead renders a
	// template passed in via a string.
	RenderText(template string, values interface{}, writer io.Writer) error
}

type ZipLoader struct {
	// contains filtered or unexported fields
}