renders

package module

v0.0.0-...-0825a3f Latest Latest Go to latest Published: Apr 20, 2023 License: BSD-3-Clause Imports: 16 Imported by: 3

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

gitea.com/tango/renders

README ¶

Renders

Middleware renders is a go template render middlewaer for Tango.

Version

v0.2.0510 Added RenderBytes for Renderer and simplifed codes.

Installation

go get gitea.com/tango/renders

Simple Example

type RenderAction struct {
    renders.Renderer
}

func (x *RenderAction) Get() {
    x.Render("test.html", renders.T{
        "test": "test",
    })
}

func main() {
    t := tango.Classic()
    t.Use(renders.New(renders.Options{
        Reload: true, // if reload when template is changed
        Directory: "./templates", // Directory to load templates
        Funcs: template.FuncMap{
            "test": func() string {
                    return "test"
            },
        },
        // Vars is a data map for global
        Vars: renders.T{
            "var": var,
        }
        Charset: "UTF-8", // Appends the given charset to the Content-Type header. Default is UTF-8
        // Allows changing of output to XHTML instead of HTML. Default is "text/html"
        HTMLContentType: "text/html",
        DelimsLeft:"{{",
        DelimsRight:"}}", // default Delims is {{}}, if it conflicts with your javascript template such as angluar, you can change it.
    }))
}

License

This project is under BSD License. See the LICENSE file for the full license text.

Documentation ¶

Index ¶

Constants
func Add(left, right int) int
func List(l *list.List) chan interface{}
func Load(opt Options) (map[string]*template.Template, error)
func LoadWithFuncMap(opt Options) (map[string]*template.Template, error)
func Range(l int) []struct{}
func RangeN(start, last int) map[int]struct{}
func Sub(left, right int) int
func Version() string
type After
type AfterBuf
type Before
type IRenderer
type Options
- func (o Options) IsExtMatch(fileName string) bool
type Renderer
- func (r *Renderer) Render(name string, bindings ...interface{}) error
- func (r *Renderer) RenderBytes(name string, binding ...interface{}) ([]byte, error)
- func (r *Renderer) SetRenderer(renders *Renders, ctx *tango.Context, before, after func(string), ...)
- func (r *Renderer) StatusRender(status int, name string, bindings ...interface{}) error
- func (r *Renderer) Template(name string) *template.Template
type Renders
- func New(options ...Options) *Renders
- func (r *Renders) Handle(ctx *tango.Context)
- func (r *Renders) Render(w io.Writer, name string, bindings ...interface{}) error
- func (r *Renders) RenderBytes(name string, bindings ...interface{}) ([]byte, error)
type T
- func (t T) Merge(at T) T

Constants ¶

View Source

const (
	ContentType   = "Content-Type"
	ContentLength = "Content-Length"
	ContentHTML   = "text/html"
	ContentXHTML  = "application/xhtml+xml"
)

Variables ¶

This section is empty.

Functions ¶

func Add ¶

func Add(left, right int) int

func List ¶

func List(l *list.List) chan interface{}

func Load ¶

func Load(opt Options) (map[string]*template.Template, error)

Load prepares and parses all templates from the passed basePath

func LoadWithFuncMap ¶

func LoadWithFuncMap(opt Options) (map[string]*template.Template, error)

LoadWithFuncMap prepares and parses all templates from the passed basePath and injects a custom template.FuncMap into each template

func Range ¶

func Range(l int) []struct{}

func RangeN ¶

func RangeN(start, last int) map[int]struct{}

func Sub ¶

func Sub(left, right int) int

func Version ¶

func Version() string

Version return the middleware's version

Types ¶

type After ¶

type After interface {
	AfterRender(string)
}

type AfterBuf ¶

type AfterBuf interface {
	AfterRender(string, io.Reader)
}

type Before ¶

type Before interface {
	BeforeRender(string)
}

type IRenderer ¶

type IRenderer interface {
	SetRenderer(*Renders, *tango.Context, func(string), func(string), func(string, io.Reader))
}

type Options ¶

type Options struct {
	// if reload templates
	Reload bool
	// Directory to load templates. Default is "templates"
	Directory string
	// Extensions to parse template files from. Defaults to [".tmpl"]
	Extensions []string
	// Funcs is a slice of FuncMaps to apply to the template upon compilation. This is useful for helper functions. Defaults to [].
	Funcs template.FuncMap
	// Vars is a data map for global
	Vars T
	// Appends the given charset to the Content-Type header. Default is "UTF-8".
	Charset string
	// Allows changing of output to XHTML instead of HTML. Default is "text/html"
	HTMLContentType string
	// default Delims
	DelimsLeft, DelimsRight string
	// where the file stored
	FileSystem http.FileSystem
}

Options is a struct for specifying configuration options for the render.Renderer middleware

func (Options) IsExtMatch ¶

func (o Options) IsExtMatch(fileName string) bool

IsExtMatch is a file name match the ext

type Renderer ¶

type Renderer struct {
	Charset         string
	HTMLContentType string
	// contains filtered or unexported fields
}

func (*Renderer) Render ¶

func (r *Renderer) Render(name string, bindings ...interface{}) error

Render a template

r.Render("index.html")
r.Render("index.html", renders.T{
           "name": value,
      })

func (*Renderer) RenderBytes ¶

func (r *Renderer) RenderBytes(name string, binding ...interface{}) ([]byte, error)

RenderBytes Will not called before & after method.

func (*Renderer) SetRenderer ¶

func (r *Renderer) SetRenderer(renders *Renders, ctx *tango.Context,
	before, after func(string), afterBuf func(string, io.Reader))

func (*Renderer) StatusRender ¶

func (r *Renderer) StatusRender(status int, name string, bindings ...interface{}) error

func (*Renderer) Template ¶

func (r *Renderer) Template(name string) *template.Template

type Renders ¶

type Renders struct {
	Options
	// contains filtered or unexported fields
}

func New ¶

func New(options ...Options) *Renders

func (*Renders) Handle ¶

func (r *Renders) Handle(ctx *tango.Context)

func (*Renders) Render ¶

func (r *Renders) Render(w io.Writer, name string, bindings ...interface{}) error

func (*Renders) RenderBytes ¶

func (r *Renders) RenderBytes(name string, bindings ...interface{}) ([]byte, error)

type T ¶

type T map[string]interface{}

Provides a common buffer to execute templates.

func (T) Merge ¶

func (t T) Merge(at T) T

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL