view

package
v12.3.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 23, 2023 License: BSD-3-Clause Imports: 23 Imported by: 0

README

View

Iris supports 8 template engines out-of-the-box, developers can still use any external golang template engine, as Context.ResponseWriter() is an io.Writer.

All template engines share a common API i.e. Parse using embedded assets, Layouts and Party-specific layout, Template Funcs, Partial Render and more.

# Name Parser
1 HTML html/template
2 Blocks kataras/blocks
3 Django flosch/pongo2
4 Pug Joker/jade
5 Handlebars mailgun/raymond
6 Amber eknkc/amber
7 Jet CloudyKit/jet
8 Ace yosssi/ace

List of Examples.

Benchmarks.

You can serve quicktemplate files too, simply by using the Context.ResponseWriter, take a look at the iris/_examples/view/quicktemplate example.

Overview

// file: main.go
package main

import "github.com/XpamAmAdEuS/iris/v12"

func main() {
    app := iris.New()
    // Load all templates from the "./views" folder
    // where extension is ".html" and parse them
    // using the standard `html/template` package.
    app.RegisterView(iris.HTML("./views", ".html"))

    // Method:    GET
    // Resource:  http://localhost:8080
    app.Get("/", func(ctx iris.Context) {
        // Bind: {{.message}} with "Hello world!"
        ctx.ViewData("message", "Hello world!")
        // Render template file: ./views/hello.html
        if err := ctx.View("hello.html"); err != nil {
		    ctx.HTML("<h3>%s</h3>", err.Error())
		    return
	    }
    })

    // Method:    GET
    // Resource:  http://localhost:8080/user/42
    app.Get("/user/{id:int64}", func(ctx iris.Context) {
        userID, _ := ctx.Params().GetInt64("id")
        ctx.Writef("User ID: %d", userID)
    })

    // Start the server using a network address.
    app.Listen(":8080")
}

<!-- file: ./views/hello.html -->
<html>
<head>
    <title>Hello Page</title>
</head>
<body>
    <h1>{{.message}}</h1>
</body>
</html>

Template functions

package main

import "github.com/XpamAmAdEuS/iris/v12"

func main() {
    app := iris.New()
    tmpl := iris.HTML("./templates", ".html")

    // builtin template funcs are:
    //
    // - {{ urlpath "mynamedroute" "pathParameter_ifneeded" }}
    // - {{ render "header.html" . }}
    // - {{ render_r "header.html" . }} // partial relative path to current page
    // - {{ yield . }}
    // - {{ current . }}

    // register a custom template func.
    tmpl.AddFunc("greet", func(s string) string {
        return "Greetings " + s + "!"
    })

    // register the view engine to the views, this will load the templates.
    app.RegisterView(tmpl)

    app.Get("/", hi)

    // http://localhost:8080
    app.Listen(":8080")
}

func hi(ctx iris.Context) {
    // render the template file "./templates/hi.html"
    if err := ctx.View("hi.html"); err != nil {
		ctx.HTML("<h3>%s</h3>", err.Error())
		return
	}
}

<!-- file: ./templates/hi.html -->
<b>{{greet "kataras"}}</b> <!-- will be rendered as: <b>Greetings kataras!</b> -->

Embedded

View engine supports bundled(https://github.com/go-bindata/go-bindata) template files too. Latest go-bindata release gives you a compatible http.FileSystem that can be provided as the first argument of a view engine's initialization, e.g. HTML(AssetFile(), ".html").

$ go install github.com/go-bindata/go-bindata/v3/go-bindata@latest
$ go-bindata -fs -prefix "templates" ./templates/...
$ go run .

Example Code:

package main

import "github.com/XpamAmAdEuS/iris/v12"

func main() {
    app := iris.New()
    app.RegisterView(iris.HTML(AssetFile(), ".html"))
    app.Get("/", hi)

    // http://localhost:8080
    app.Listen(":8080")
}

type page struct {
    Title, Name string
}

func hi(ctx iris.Context) {
    //                      {{.Page.Title}} and {{Page.Name}}
    ctx.ViewData("Page", page{Title: "Hi Page", Name: "iris"})
    if err := ctx.View("hi.html"); err != nil {
		ctx.HTML("<h3>%s</h3>", err.Error())
		return
	}
}

Examples can be found here: https://github.com/XpamAmAdEuS/iris/tree/master/_examples/view/embedding-templates-into-app and https://github.com/XpamAmAdEuS/iris/tree/master/_examples/view/embedding-templates-into-app-bindata.

Reload

Enable auto-reloading of templates on each request. Useful while developers are in dev mode as they no neeed to restart their app on every template edit.

Example code:

pugEngine := iris.Pug("./templates", ".jade")
pugEngine.Reload(true) // <--- set to true to re-build the templates on each request.
app.RegisterView(pugEngine)

Documentation

Index

Constants

View Source 
const JetRuntimeVarsContextKey = "iris.jetvarmap"

JetRuntimeVarsContextKey is the Iris Context key to keep any custom jet runtime variables. See `AddJetRuntimeVars` package-level function and `JetEngine.AddRuntimeVars` method.

View Source 
const NoLayout = "iris.nolayout"

NoLayout disables the configuration's layout for a specific execution.

Variables

View Source 
var AsSafeValue = pongo2.AsSafeValue

AsSafeValue works like AsValue, but does not apply the 'escape' filter. Shortcut for `pongo2.AsSafeValue`.

View Source 
var AsValue = pongo2.AsValue

AsValue converts any given value to a pongo2.Value Usually being used within own functions passed to a template through a Context or within filter functions.

Example: 

AsValue("my string")

Shortcut for `pongo2.AsValue`.

Functions

func AddJetRuntimeVars 

func AddJetRuntimeVars(ctx *context.Context, jetVarMap JetRuntimeVars)

AddJetRuntimeVars sets or inserts runtime jet variables through the Iris Context. This gives the ability to add runtime variables from different handlers in the request chain, something that the jet template parser does not offer at all.

Usage: view.AddJetRuntimeVars(ctx, view.JetRuntimeVars{...}). See `JetEngine.AddRuntimeVars` too.

Types

type AceEngine 

type AceEngine struct {
	*HTMLEngine
	// contains filtered or unexported fields
}

AceEngine represents the Ace view engine. See the `Ace` package-level function for more.

func Ace 

func Ace(fs interface{}, extension string) *AceEngine

Ace returns a new Ace view engine. It shares the same exactly logic with the html view engine, it uses the same exactly configuration. The given "extension" MUST begin with a dot. Ace minifies the response automatically unless SetIndent() method is set.

Read more about the Ace Go Parser: https://github.com/yosssi/ace

Usage: Ace("./views", ".ace") or Ace(iris.Dir("./views"), ".ace") or Ace(embed.FS, ".ace") or Ace(AssetFile(), ".ace") for embedded data.

func (*AceEngine) SetIndent 

func (s *AceEngine) SetIndent(indent string) *AceEngine

SetIndent string used for indentation. Do NOT use tabs, only spaces characters. Defaults to minified response, no indentation.

type AmberEngine 

type AmberEngine struct {
	Options amber.Options
	// contains filtered or unexported fields
}

AmberEngine contains the amber view engine structure.

func Amber 

func Amber(dirOrFS interface{}, extension string) *AmberEngine

Amber creates and returns a new amber view engine. The given "extension" MUST begin with a dot.

Usage: Amber("./views", ".amber") or Amber(iris.Dir("./views"), ".amber") or Amber(embed.FS, ".amber") or Amber(AssetFile(), ".amber") for embedded data.

func (*AmberEngine) AddFunc 

func (s *AmberEngine) AddFunc(funcName string, funcBody interface{})

AddFunc adds the function to the template's function map. It is legal to overwrite elements of the default actions: - url func(routeName string, args ...string) string - urlpath func(routeName string, args ...string) string - render func(fullPartialName string) (template.HTML, error).

Note that, Amber does not support functions per template, instead it's using the "call" directive so any template-specific functions should be passed using `Context.View/ViewData` binding data. This method will modify the global amber's FuncMap which considers as the "builtin" as this is the only way to actually add a function. Note that, if you use more than one amber engine, the functions are shared.

func (*AmberEngine) ExecuteWriter 

func (s *AmberEngine) ExecuteWriter(w io.Writer, filename string, layout string, bindingData interface{}) error

ExecuteWriter executes a template and writes its result to the w writer. layout here is useless.

func (*AmberEngine) Ext 

func (s *AmberEngine) Ext() string

Ext returns the file extension which this view engine is responsible to render. If the filename extension on ExecuteWriter is empty then this is appended.

func (*AmberEngine) Load 

func (s *AmberEngine) Load() error

Load parses the templates to the engine. It is responsible to add the necessary global functions.

Returns an error if something bad happens, user is responsible to catch it.

func (*AmberEngine) Name 

func (s *AmberEngine) Name() string

Name returns the amber engine's name.

func (*AmberEngine) ParseTemplate 

func (s *AmberEngine) ParseTemplate(name string, contents []byte) error

ParseTemplate adds a custom template from text. This template parser does not support funcs per template directly. Two ways to add a function: Globally: Use `AddFunc` or pass them on `View` instead. Per Template: Use `Context.ViewData/View`.

func (*AmberEngine) Reload 

func (s *AmberEngine) Reload(developmentMode bool) *AmberEngine

Reload if set to true the templates are reloading on each render, use it when you're in development and you're boring of restarting the whole app when you edit a template file.

Note that if `true` is passed then only one `View -> ExecuteWriter` will be render each time, no concurrent access across clients, use it only on development status. It's good to be used side by side with the https://github.com/kataras/rizla reloader for go source files.

func (*AmberEngine) RootDir 

func (s *AmberEngine) RootDir(root string) *AmberEngine

RootDir sets the directory to be used as a starting point to load templates from the provided file system.

func (*AmberEngine) SetPrettyPrint 

func (s *AmberEngine) SetPrettyPrint(pretty bool) *AmberEngine

SetPrettyPrint if pretty printing is enabled. Pretty printing ensures that the output html is properly indented and in human readable form. Defaults to false, response is minified.

type BlocksEngine 

type BlocksEngine struct {
	Engine *blocks.Blocks
}

BlocksEngine is an Iris view engine adapter for the blocks view engine. The blocks engine is based on the html/template standard Go package.

To initialize a fresh one use the `Blocks` function. To wrap an existing one use the `WrapBlocks` function.

It contains the following four default template functions: - url "routename" parameters... - urlpath "routename" parameters... - tr "language" "key" arguments... - partial "template_name" data

Read more at: https://github.com/kataras/blocks.

func Blocks 

func Blocks(fs interface{}, extension string) *BlocksEngine

Blocks returns a new blocks view engine. The given "extension" MUST begin with a dot.

See `WrapBlocks` package-level function too.

Usage: Blocks("./views", ".html") or Blocks(iris.Dir("./views"), ".html") or Blocks(embed.FS, ".html") or Blocks(AssetFile(), ".html") for embedded data.

func WrapBlocks 

func WrapBlocks(v *blocks.Blocks) *BlocksEngine

WrapBlocks wraps an initialized blocks engine and returns its Iris adapter. See `Blocks` package-level function too.

func (*BlocksEngine) AddFunc 

func (s *BlocksEngine) AddFunc(funcName string, funcBody interface{})

AddFunc implements the `EngineFuncer` which is being used by the framework to add template functions like: - url func(routeName string, args ...string) string - urlpath func(routeName string, args ...string) string - tr func(lang, key string, args ...interface{}) string

func (*BlocksEngine) AddLayoutFunc 

func (s *BlocksEngine) AddLayoutFunc(funcName string, funcBody interface{}) *BlocksEngine

AddLayoutFunc adds a template function for templates that are marked as layouts.

func (*BlocksEngine) ExecuteWriter 

func (s *BlocksEngine) ExecuteWriter(w io.Writer, tmplName, layoutName string, data interface{}) error

ExecuteWriter renders a template on "w".

func (*BlocksEngine) Ext 

func (s *BlocksEngine) Ext() string

Ext returns empty ext as this template engine supports template blocks without file suffix. Note that, if more than one view engine is registered to a single Iris application then, this Blocks engine should be the last entry one.

func (*BlocksEngine) Layout 

func (s *BlocksEngine) Layout(layoutName string) *BlocksEngine

Layout sets the default layout which inside should use the {{ template "content" . }} to render the main template.

Example for ./views/layouts/main.html: Blocks("./views", ".html").Layout("layouts/main")

func (*BlocksEngine) LayoutDir 

func (s *BlocksEngine) LayoutDir(relToDirLayoutDir string) *BlocksEngine

LayoutDir sets a custom layouts directory, always relative to the "rootDir" one. Layouts are recognised by their prefix names. Defaults to "layouts".

func (*BlocksEngine) Load 

func (s *BlocksEngine) Load() error

Load parses the files into templates.

func (*BlocksEngine) Name 

func (s *BlocksEngine) Name() string

Name returns the blocks engine's name.

func (*BlocksEngine) Reload 

func (s *BlocksEngine) Reload(b bool) *BlocksEngine

Reload if called with a true parameter, each `ExecuteWriter` call will re-parse the templates. Useful when the application is at a development stage.

func (*BlocksEngine) RootDir 

func (s *BlocksEngine) RootDir(root string) *BlocksEngine

RootDir sets the directory to use as the root one inside the provided File System.

type DjangoEngine 

type DjangoEngine struct {
	Set *pongo2.TemplateSet
	// contains filtered or unexported fields
}

DjangoEngine contains the django view engine structure.

func Django 

func Django(fs interface{}, extension string) *DjangoEngine

Django creates and returns a new django view engine. The given "extension" MUST begin with a dot.

Usage: Django("./views", ".html") or Django(iris.Dir("./views"), ".html") or Django(embed.FS, ".html") or Django(AssetFile(), ".html") for embedded data.

func (*DjangoEngine) AddFilter 

func (s *DjangoEngine) AddFilter(filterName string, filterBody FilterFunction) *DjangoEngine

AddFilter registers a new filter. If there's already a filter with the same name, RegisterFilter will panic. You usually want to call this function in the filter's init() function: http://golang.org/doc/effective_go.html#init

Same as `RegisterFilter`.

func (*DjangoEngine) AddFunc 

func (s *DjangoEngine) AddFunc(funcName string, funcBody interface{})

AddFunc adds the function to the template's Globals. It is legal to overwrite elements of the default actions: - url func(routeName string, args ...string) string - urlpath func(routeName string, args ...string) string - render func(fullPartialName string) (template.HTML, error).

func (*DjangoEngine) ExecuteWriter 

func (s *DjangoEngine) ExecuteWriter(w io.Writer, filename string, _ string, bindingData interface{}) error

ExecuteWriter executes a templates and write its results to the w writer layout here is useless.

func (*DjangoEngine) Ext 

func (s *DjangoEngine) Ext() string

Ext returns the file extension which this view engine is responsible to render. If the filename extension on ExecuteWriter is empty then this is appended.

func (*DjangoEngine) Load 

func (s *DjangoEngine) Load() error

Load parses the templates to the engine. It is responsible to add the necessary global functions.

Returns an error if something bad happens, user is responsible to catch it.

func (*DjangoEngine) Name 

func (s *DjangoEngine) Name() string

Name returns the django engine's name.

func (*DjangoEngine) ParseTemplate 

func (s *DjangoEngine) ParseTemplate(name string, contents []byte) error

ParseTemplate adds a custom template from text. This parser does not support funcs per template. Use the `AddFunc` instead.

func (*DjangoEngine) RegisterFilter 

func (s *DjangoEngine) RegisterFilter(filterName string, filterBody FilterFunction) *DjangoEngine

RegisterFilter registers a new filter. If there's already a filter with the same name, RegisterFilter will panic. You usually want to call this function in the filter's init() function: http://golang.org/doc/effective_go.html#init

See http://www.florian-schlachter.de/post/pongo2/ for more about writing filters and tags.

func (*DjangoEngine) RegisterTag 

func (s *DjangoEngine) RegisterTag(tagName string, fn TagParser) error

RegisterTag registers a new tag. You usually want to call this function in the tag's init() function: http://golang.org/doc/effective_go.html#init

See http://www.florian-schlachter.de/post/pongo2/ for more about writing filters and tags.

func (*DjangoEngine) Reload 

func (s *DjangoEngine) Reload(developmentMode bool) *DjangoEngine

Reload if set to true the templates are reloading on each render, use it when you're in development and you're boring of restarting the whole app when you edit a template file.

Note that if `true` is passed then only one `View -> ExecuteWriter` will be render each time, no concurrent access across clients, use it only on development status. It's good to be used side by side with the https://github.com/kataras/rizla reloader for go source files.

func (*DjangoEngine) RootDir 

func (s *DjangoEngine) RootDir(root string) *DjangoEngine

RootDir sets the directory to be used as a starting point to load templates from the provided file system.

type Engine 

type Engine = context.ViewEngine

Engine is the interface for a compatible Iris view engine. It's an alias of context.ViewEngine.

type EngineFuncer 

type EngineFuncer = context.ViewEngineFuncer

EngineFuncer is the interface for a compatible Iris view engine which accepts builtin framework functions such as url, urlpath and tr. It's an alias of context.ViewEngineFuncer.

type ErrNotExist 

type ErrNotExist = context.ErrViewNotExist

ErrNotExist reports whether a template was not found in the parsed templates tree.

type Error 

type Error = pongo2.Error

Error type alias for pongo2.Error

type FilterFunction 

type FilterFunction = pongo2.FilterFunction

FilterFunction type alias for pongo2.FilterFunction

type HTMLEngine 

type HTMLEngine struct {
	Templates *template.Template
	// contains filtered or unexported fields
}

HTMLEngine contains the html view engine structure.

func HTML 

func HTML(dirOrFS interface{}, extension string) *HTMLEngine

HTML creates and returns a new html view engine. The html engine used like the "html/template" standard go package but with a lot of extra features. The given "extension" MUST begin with a dot.

Usage: HTML("./views", ".html") or HTML(iris.Dir("./views"), ".html") or HTML(embed.FS, ".html") or HTML(AssetFile(), ".html") for embedded data.

func Pug 

func Pug(fs interface{}, extension string) *HTMLEngine

Pug (or Jade) returns a new pug view engine. It shares the same exactly logic with the html view engine, it uses the same exactly configuration. The given "extension" MUST begin with a dot.

Read more about the Jade Go Parser: https://github.com/Joker/jade

Usage: Pug("./views", ".pug") or Pug(iris.Dir("./views"), ".pug") or Pug(embed.FS, ".pug") or Pug(AssetFile(), ".pug") for embedded data.

Examples: https://github.com/XpamAmAdEuS/iris/tree/master/_examples/view/template_pug_0 https://github.com/XpamAmAdEuS/iris/tree/master/_examples/view/template_pug_1 https://github.com/XpamAmAdEuS/iris/tree/master/_examples/view/template_pug_2 https://github.com/XpamAmAdEuS/iris/tree/master/_examples/view/template_pug_3

func (*HTMLEngine) AddFunc 

func (s *HTMLEngine) AddFunc(funcName string, funcBody interface{})

AddFunc adds the function to the template's function map. It is legal to overwrite elements of the default actions: - url func(routeName string, args ...string) string - urlpath func(routeName string, args ...string) string - render func(fullPartialName string) (template.HTML, error). - tr func(lang, key string, args ...interface{}) string

func (*HTMLEngine) AddLayoutFunc 

func (s *HTMLEngine) AddLayoutFunc(funcName string, funcBody interface{}) *HTMLEngine

AddLayoutFunc adds the function to the template's layout-only function map. It is legal to overwrite elements of the default layout actions: - yield func() (template.HTML, error) - current func() (string, error) - partial func(partialName string) (template.HTML, error) - partial_r func(partialName string) (template.HTML, error) - render func(fullPartialName string) (template.HTML, error).

func (*HTMLEngine) Delims 

func (s *HTMLEngine) Delims(left, right string) *HTMLEngine

Delims sets the action delimiters to the specified strings, to be used in templates. An empty delimiter stands for the corresponding default: {{ or }}.

func (*HTMLEngine) ExecuteWriter 

func (s *HTMLEngine) ExecuteWriter(w io.Writer, name string, layout string, bindingData interface{}) error

ExecuteWriter executes a template and writes its result to the w writer.

func (*HTMLEngine) Ext 

func (s *HTMLEngine) Ext() string

Ext returns the file extension which this view engine is responsible to render. If the filename extension on ExecuteWriter is empty then this is appended.

func (*HTMLEngine) Funcs 

func (s *HTMLEngine) Funcs(funcMap template.FuncMap) *HTMLEngine

Funcs adds the elements of the argument map to the template's function map. It is legal to overwrite elements of the map. The return value is the template, so calls can be chained.

func (*HTMLEngine) Layout 

func (s *HTMLEngine) Layout(layoutFile string) *HTMLEngine

Layout sets the layout template file which inside should use the {{ yield . }} func to yield the main template file and optionally {{partial/partial_r/render . }} to render other template files like headers and footers

The 'tmplLayoutFile' is a relative path of the templates base directory, for the template file with its extension.

Example: HTML("./templates", ".html").Layout("layouts/mainLayout.html") 

// mainLayout.html is inside: "./templates/layouts/".

Note: Layout can be changed for a specific call action with the option: "layout" on the iris' context.Render function.

func (*HTMLEngine) Load 

func (s *HTMLEngine) Load() error

Load parses the templates to the engine. It's also responsible to add the necessary global functions.

Returns an error if something bad happens, caller is responsible to handle that.

func (*HTMLEngine) Name 

func (s *HTMLEngine) Name() string

Name returns the engine's name.

func (*HTMLEngine) Option 

func (s *HTMLEngine) Option(opt ...string) *HTMLEngine

Option sets options for the template. Options are described by strings, either a simple string or "key=value". There can be at most one equals sign in an option string. If the option string is unrecognized or otherwise invalid, Option panics.

Known options:

missingkey: Control the behavior during execution if a map is indexed with a key that is not present in the map. 

"missingkey=default" or "missingkey=invalid"
	The default behavior: Do nothing and continue execution.
	If printed, the result of the index operation is the string
	"<no value>".
"missingkey=zero"
	The operation returns the zero value for the map type's element.
"missingkey=error"
	Execution stops immediately with an error.

func (*HTMLEngine) ParseTemplate 

func (s *HTMLEngine) ParseTemplate(name string, contents []byte, funcs template.FuncMap) (err error)

ParseTemplate adds a custom template to the root template.

func (*HTMLEngine) Reload 

func (s *HTMLEngine) Reload(developmentMode bool) *HTMLEngine

Reload if set to true the templates are reloading on each render, use it when you're in development and you're boring of restarting the whole app when you edit a template file.

Note that if `true` is passed then only one `View -> ExecuteWriter` will be render each time, no concurrent access across clients, use it only on development status. It's good to be used side by side with the https://github.com/kataras/rizla reloader for go source files.

func (*HTMLEngine) RootDir 

func (s *HTMLEngine) RootDir(root string) *HTMLEngine

RootDir sets the directory to be used as a starting point to load templates from the provided file system.

func (*HTMLEngine) SetFuncs 

func (s *HTMLEngine) SetFuncs(funcMap template.FuncMap) *HTMLEngine

SetFuncs overrides the template funcs with the given "funcMap".

type HandlebarsEngine 

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

HandlebarsEngine contains the handlebars view engine structure.

func Handlebars 

func Handlebars(fs interface{}, extension string) *HandlebarsEngine

Handlebars creates and returns a new handlebars view engine. The given "extension" MUST begin with a dot.

Usage: Handlebars("./views", ".html") or Handlebars(iris.Dir("./views"), ".html") or Handlebars(embed.FS, ".html") or Handlebars(AssetFile(), ".html") for embedded data.

func (*HandlebarsEngine) AddFunc 

func (s *HandlebarsEngine) AddFunc(funcName string, funcBody interface{})

AddFunc adds a function to the templates. It is legal to overwrite elements of the default actions: - url func(routeName string, args ...string) string - urlpath func(routeName string, args ...string) string - render func(fullPartialName string) (raymond.HTML, error).

func (*HandlebarsEngine) AddGlobalFunc 

func (s *HandlebarsEngine) AddGlobalFunc(funcName string, funcBody interface{})

AddGlobalFunc registers a global template function for all Handlebars view engines.

func (*HandlebarsEngine) ExecuteWriter 

func (s *HandlebarsEngine) ExecuteWriter(w io.Writer, filename string, layout string, bindingData interface{}) error

ExecuteWriter executes a template and writes its result to the w writer.

func (*HandlebarsEngine) Ext 

func (s *HandlebarsEngine) Ext() string

Ext returns the file extension which this view engine is responsible to render. If the filename extension on ExecuteWriter is empty then this is appended.

func (*HandlebarsEngine) Layout 

func (s *HandlebarsEngine) Layout(layoutFile string) *HandlebarsEngine

Layout sets the layout template file which should use the {{ yield . }} func to yield the main template file and optionally {{partial/partial_r/render . }} to render other template files like headers and footers.

func (*HandlebarsEngine) Load 

func (s *HandlebarsEngine) Load() error

Load parses the templates to the engine. It is responsible to add the necessary global functions.

Returns an error if something bad happens, user is responsible to catch it.

func (*HandlebarsEngine) Name 

func (s *HandlebarsEngine) Name() string

Name returns the handlebars engine's name.

func (*HandlebarsEngine) ParseTemplate 

func (s *HandlebarsEngine) ParseTemplate(name string, contents string, funcs template.FuncMap) error

ParseTemplate adds a custom template from text.

func (*HandlebarsEngine) Reload 

func (s *HandlebarsEngine) Reload(developmentMode bool) *HandlebarsEngine

Reload if set to true the templates are reloading on each render, use it when you're in development and you're boring of restarting the whole app when you edit a template file.

Note that if `true` is passed then only one `View -> ExecuteWriter` will be render each time, no concurrent access across clients, use it only on development status. It's good to be used side by side with the https://github.com/kataras/rizla reloader for go source files.

func (*HandlebarsEngine) RootDir 

func (s *HandlebarsEngine) RootDir(root string) *HandlebarsEngine

RootDir sets the directory to be used as a starting point to load templates from the provided file system.

type INodeTag 

type INodeTag = pongo2.INodeTag

INodeTag type alias for pongo2.InodeTag

type JetArguments 

type JetArguments = jet.Arguments

JetArguments is a type alias of `jet.Arguments`, can be used on `AddFunc$funcBody`.

type JetEngine 

type JetEngine struct {

	// The Set is the `*jet.Set`, exported to offer any custom capabilities that jet users may want.
	// Available after `Load`.
	Set *jet.Set
	// contains filtered or unexported fields
}

JetEngine is the jet template parser's view engine.

func Jet 

func Jet(dirOrFS interface{}, extension string) *JetEngine

Jet creates and returns a new jet view engine. The given "extension" MUST begin with a dot.

Usage: Jet("./views", ".jet") or Jet(iris.Dir("./views"), ".jet") or Jet(embed.FS, ".jet") or Jet(AssetFile(), ".jet") for embedded data.

func (*JetEngine) AddFunc 

func (s *JetEngine) AddFunc(funcName string, funcBody interface{})

AddFunc should adds a global function to the jet template set.

func (*JetEngine) AddRuntimeVars 

func (s *JetEngine) AddRuntimeVars(ctx *context.Context, vars JetRuntimeVars)

AddRuntimeVars sets or inserts runtime jet variables through the Iris Context. This gives the ability to add runtime variables from different handlers in the request chain, something that the jet template parser does not offer at all.

Usage: view.AddJetRuntimeVars(ctx, view.JetRuntimeVars{...}). See `view.AddJetRuntimeVars` if package-level access is more meanful to the code flow.

func (*JetEngine) AddVar 

func (s *JetEngine) AddVar(key string, value interface{})

AddVar adds a global variable to the jet template set.

func (*JetEngine) Delims 

func (s *JetEngine) Delims(left, right string) *JetEngine

Delims sets the action delimiters to the specified strings, to be used in templates. An empty delimiter stands for the corresponding default: {{ or }}. Should act before `Load` or `iris.Application#RegisterView`.

func (*JetEngine) ExecuteWriter 

func (s *JetEngine) ExecuteWriter(w io.Writer, filename string, layout string, bindingData interface{}) error

ExecuteWriter should execute a template by its filename with an optional layout and bindingData.

func (*JetEngine) Ext 

func (s *JetEngine) Ext() string

Ext should return the final file extension which this view engine is responsible to render. If the filename extension on ExecuteWriter is empty then this is appended.

func (*JetEngine) Load 

func (s *JetEngine) Load() error

Load should load the templates from a physical system directory or by an embedded one (assets/go-bindata).

func (*JetEngine) Name 

func (s *JetEngine) Name() string

Name returns the jet engine's name.

func (*JetEngine) ParseTemplate 

func (s *JetEngine) ParseTemplate(name string, contents string) error

ParseTemplate accepts a name and contnets to parse and cache a template. This parser does not support funcs per template. Use the `AddFunc` instead.

func (*JetEngine) Reload 

func (s *JetEngine) Reload(developmentMode bool) *JetEngine

Reload if setted to true the templates are reloading on each render, use it when you're in development and you're boring of restarting the whole app when you edit a template file.

Note that if `true` is passed then only one `View -> ExecuteWriter` will be render each time, not safe concurrent access across clients, use it only on development state.

func (*JetEngine) RootDir 

func (s *JetEngine) RootDir(root string) *JetEngine

RootDir sets the directory to be used as a starting point to load templates from the provided file system.

func (*JetEngine) SetLoader 

func (s *JetEngine) SetLoader(loader jet.Loader) *JetEngine

SetLoader can be used when the caller wants to use something like multi.Loader or httpfs.Loader.

func (*JetEngine) String 

func (s *JetEngine) String() string

String returns the name of this view engine, the "jet".

type JetRuntime 

type JetRuntime = jet.Runtime

JetRuntime is a type alias of `jet.Runtime`, can be used on RuntimeVariable input function.

type JetRuntimeVars 

type JetRuntimeVars = jet.VarMap

JetRuntimeVars is a type alias for `jet.VarMap`. Can be used at `AddJetRuntimeVars/JetEngine.AddRuntimeVars` to set a runtime variable ${name} to the executing template.

type Parser 

type Parser = pongo2.Parser

Parser type alias for pongo2.Parser

type TagParser 

type TagParser = pongo2.TagParser

TagParser the function signature of the tag's parser you will have to implement in order to create a new tag.

'doc' is providing access to the whole document while 'arguments' is providing access to the user's arguments to the tag: 

{% your_tag_name some "arguments" 123 %}

start_token will be the *Token with the tag's name in it (here: your_tag_name).

Please see the Parser documentation on how to use the parser. See `RegisterTag` for more information about writing a tag as well.

type Token 

type Token = pongo2.Token

Token type alias for pongo2.Token

type Value 

type Value = pongo2.Value

Value type alias for pongo2.Value

type View 

type View struct{ Engine }

View is just a wrapper on top of the registered template engine.

func (*View) AddFunc 

func (v *View) AddFunc(funcName string, funcBody interface{})

AddFunc adds a function to all registered engines. Each template engine that supports functions has its own AddFunc too.

func (*View) ExecuteWriter 

func (v *View) ExecuteWriter(w io.Writer, filename string, layout string, bindingData interface{}) error

ExecuteWriter calls the correct view Engine's ExecuteWriter func

func (*View) Funcs 

func (v *View) Funcs(m template.FuncMap) *View

Funcs registers a template func map to the registered view engine(s).

func (*View) Load 

func (v *View) Load() error

Load compiles all the registered engines.

func (*View) Register 

func (v *View) Register(e Engine)

Register registers a view engine.

func (*View) Registered 

func (v *View) Registered() bool

Registered reports whether an engine was registered.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.