templates

type CSS ¶

type CSS string

CSS implements the CSSStringer interface.

func (css CSS) CSS() string

type CSSEnvStringer ¶

type CSSEnvStringer interface {
	CSS(runtime.Env) string
}

CSSEnvStringer is like CSSStringer where the CSS method takes a runtime.Env parameter.

type CSSStringer ¶

type CSSStringer interface {
	CSS() string
}

CSSStringer is implemented by values that are not escaped in CSS context.

type CompilerError ¶

type CompilerError interface {
	error
	Position() ast.Position
	Path() string
	Message() string
}

CompilerError represents an error returned by the compiler.

type Declarations ¶

type Declarations map[string]interface{}

Declarations.

func Builtins() Declarations

type DirLimitedReader ¶

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

DirLimitedReader implements a FileReader that reads a source from files in a directory limiting the maximum file size and the total bytes read from all reads.

Use DirLimitedReader, instead of DirReader, when you do not have control of file sizes. As a Parser reads a file with a specific context only once, DirLimitedReader can be passed to a Parser to prevent it from allocating too much memory.

func NewDirLimitedReader(dir string, maxFile, maxTotal int) *DirLimitedReader

func (dr *DirLimitedReader) ReadFile(name string) ([]byte, error)

type DirReader ¶

type DirReader string

DirReader implements a FileReader that reads the files in a directory.

To limit the size of read files, use DirLimitedReader instead.

func (dir DirReader) ReadFile(name string) ([]byte, error)

type EnvStringer ¶

type EnvStringer interface {
	String(runtime.Env) string
}

EnvStringer is like fmt.Stringer where the String method takes a runtime.Env parameter.

type FileReader ¶

type FileReader interface {
	ReadFile(name string) ([]byte, error)
}

FileReader is implemented by values that can read files of a template. name, if not absolute, is relative to the root of the template. If the file with the given name does not exist, it returns nil and an os not found error.

type HTML ¶

type HTML string

HTML implements the HTMLStringer interface.

func (html HTML) HTML() string

type HTMLEnvStringer ¶

type HTMLEnvStringer interface {
	HTML(runtime.Env) string
}

HTMLEnvStringer is like HTMLStringer where the HTML method takes a runtime.Env parameter.

type HTMLStringer ¶

type HTMLStringer interface {
	HTML() string
}

HTMStringer is implemented by values that are not escaped in HTML context.

type JavaScript ¶

type JavaScript string

JavaScript implements the JavaScriptStringer interface.

func (js JavaScript) JavaScript() string

type JavaScriptEnvStringer ¶

type JavaScriptEnvStringer interface {
	JavaScript(runtime.Env) string
}

JavaScriptEnvStringer is like JavaScriptStringer where the JavaScript method takes a runtime.Env parameter.

type JavaScriptStringer ¶

type JavaScriptStringer interface {
	JavaScript() string
}

JavaScriptStringer is implemented by values that are not escaped in JavaScript context.

type Language ¶

type Language int

A Language represents a source language.

const (
	LanguageText Language = iota
	LanguageHTML
	LanguageCSS
	LanguageJavaScript
)

func (language Language) String() string

type LoadOptions ¶

type LoadOptions struct {
	DisallowGoStmt  bool
	TreeTransformer func(*ast.Tree) error // if not nil transforms tree after parsing.

	// Builtins declares constants, types, variables and functions that are
	// accessible from the code in the template.
	Builtins Declarations

	// Loader is a package loader that makes precompiled packages available in
	// the template through the 'import' statement.
	//
	// Note that an import statement refers to a precompiled package read from
	// the Loader if its path has no extension.
	//
	//     {%  import  "my/package"   %}    Import a precompiled package.
	//     {%  import  "my/file.html  %}    Import a template file.
	//
	Loader scriggo.PackageLoader
}

type MapReader ¶

type MapReader map[string][]byte

MapReader implements a FileReader where sources are read from a map. Map keys are the file names. If a name is present both relative and absolute, the file of the absolute one is returned.

func (r MapReader) ReadFile(name string) ([]byte, error)

type PrintTypeError ¶

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

func (err PrintTypeError) Error() string

func (err PrintTypeError) RuntimeError()

type RenderOptions ¶

type RenderOptions struct {
	Context   context.Context
	PrintFunc runtime.PrintFunc
}

type Template ¶

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

func Load(name string, files FileReader, lang Language, options *LoadOptions) (*Template, error)

func (t *Template) Disassemble(w io.Writer) (int64, error)

func (t *Template) MustRender(out io.Writer, vars map[string]interface{}, options *RenderOptions)

func (t *Template) Render(out io.Writer, vars map[string]interface{}, options *RenderOptions) error

func (t *Template) Vars() []string