plush: Index | Examples | Files | Directories

package plush

import ""



Package Files

compiler.go context.go forms.go helper_map.go helpers.go iterators.go markdown_helper.go partial_helper.go plush.go template.go user_function.go


var BootstrapFormForHelper = bootstrap.FormFor

BootstrapFormForHelper is deprecated use instead.

var BootstrapFormHelper = bootstrap.Form

BootstrapFormHelper is deprecated use instead.

var DefaultTimeFormat = "January 02, 2006 15:04:05 -0700"

DefaultTimeFormat is the default way of formatting a time.Time type. This a **GLOBAL** variable, so if you change it, it will change for templates rendered through the `plush` package. If you want to set a specific time format for a particular call to `Render` you can set the `TIME_FORMAT` in the context.

ctx.Set("TIME_FORMAT", "2006-02-Jan")
s, err = Render(input, ctx)
var FormForHelper = forms.FormFor

FormForHelper is deprecated use instead.

var FormHelper = forms.Form

FormHelper is deprecated use instead.

var Helpers = HelperMap{
    // contains filtered or unexported fields

Helpers contains all of the default helpers for These will be available to all templates. You should add any custom global helpers to this list.

func BuffaloRenderer Uses

func BuffaloRenderer(input string, data map[string]interface{}, helpers map[string]interface{}) (string, error)

BuffaloRenderer implements the render.TemplateEngine interface allowing velvet to be used as a template engine for Buffalo

func MarkdownHelper Uses

func MarkdownHelper(body string, help HelperContext) (template.HTML, error)

Markdown converts the string into HTML using GitHub flavored markdown.

func Render Uses

func Render(input string, ctx hctx.Context) (string, error)

Render a string using the given the context.

ExampleRender using `if`, `for`, `else`, functions, etc...


html := `<html>
<%= if (names && len(names) > 0) { %>
<%= for (n) in names { %>
	<li><%= capitalize(n) %></li>
<% } %>
<% } else { %>
	<h1>Sorry, no names. :(</h1>
<% } %>

ctx := NewContext()
ctx.Set("names", []string{"john", "paul", "george", "ringo"})

s, err := Render(html, ctx)
if err != nil {












html := `<p><%= one() %></p>
<p><%= greet("mark")%></p>
<%= can("update") { %>
<p>i can update</p>
<% } %>
<%= can("destroy") { %>
<p>i can destroy</p>
<% } %>

ctx := NewContext()
ctx.Set("one", func() int {
    return 1
ctx.Set("greet", func(s string) string {
    return fmt.Sprintf("Hi %s", s)
ctx.Set("can", func(s string, help HelperContext) (template.HTML, error) {
    if s == "update" {
        h, err := help.Block()
        return template.HTML(h), err
    return "", nil

s, err := Render(html, ctx)
if err != nil {


<p>Hi mark</p>

<p>i can update</p>


html := `<%= for (v) in between(3,6) { %><%=v%><% } %>`

s, err := Render(html, NewContext())
if err != nil {




html := `<%
let h = {name: "mark"}
let greet = fn(n) {
  return "hi " + n
<h1><%= greet(h["name"]) %></h1>`

s, err := Render(html, NewContext())
if err != nil {


<h1>hi mark</h1>

func RenderR Uses

func RenderR(input io.Reader, ctx hctx.Context) (string, error)

func RunScript Uses

func RunScript(input string, ctx hctx.Context) error

RunScript allows for "pure" plush scripts to be executed.

type Context Uses

type Context struct {
    // contains filtered or unexported fields

Context holds all of the data for the template that is being rendered.

func NewContext Uses

func NewContext() *Context

NewContext returns a fully formed context ready to go

func NewContextWith Uses

func NewContextWith(data map[string]interface{}) *Context

NewContextWith returns a fully formed context using the data provided.

func NewContextWithContext Uses

func NewContextWithContext(ctx context.Context) *Context

NewContextWithContext returns a new plush.Context given another context

func (*Context) Has Uses

func (c *Context) Has(key string) bool

Has checks the existence of the key in the context.

func (*Context) New Uses

func (c *Context) New() hctx.Context

New context containing the current context. Values set on the new context will not be set onto the original context, however, the original context's values will be available to the new context.

func (*Context) Set Uses

func (c *Context) Set(key string, value interface{})

Set a value onto the context

func (*Context) Value Uses

func (c *Context) Value(key interface{}) interface{}

Value from the context, or it's parent's context if one exists.

type ErrUnknownIdentifier Uses

type ErrUnknownIdentifier struct {
    ID  string
    Err error

func (*ErrUnknownIdentifier) Error Uses

func (e *ErrUnknownIdentifier) Error() string

type HTMLer Uses

type HTMLer interface {
    HTML() template.HTML

HTMLer generates HTML source

type HelperContext Uses

type HelperContext struct {
    // contains filtered or unexported fields

HelperContext is an optional last argument to helpers that provides the current context of the call, and access to an optional "block" of code that can be executed from within the helper.

func (HelperContext) Block Uses

func (h HelperContext) Block() (string, error)

Block executes the block of template associated with the helper, think the block inside of an "if" or "each" statement.

func (HelperContext) BlockWith Uses

func (h HelperContext) BlockWith(hc hctx.Context) (string, error)

BlockWith executes the block of template associated with the helper, think the block inside of an "if" or "each" statement, but with it's own context.

func (HelperContext) HasBlock Uses

func (h HelperContext) HasBlock() bool

HasBlock returns true if a block is associated with the helper function

func (HelperContext) Render Uses

func (h HelperContext) Render(s string) (string, error)

Render a string with the current context

type HelperMap Uses

type HelperMap struct {
    // contains filtered or unexported fields

HelperMap holds onto helpers and validates they are properly formed.

func NewHelperMap Uses

func NewHelperMap() (HelperMap, error)

NewHelperMap containing all of the "default" helpers from "plush.Helpers".

func (*HelperMap) Add Uses

func (h *HelperMap) Add(key string, helper interface{}) error

Add a new helper to the map. New Helpers will be validated to ensure they meet the requirements for a helper:

func (*HelperMap) AddMany Uses

func (h *HelperMap) AddMany(helpers map[string]interface{}) error

AddMany helpers at the same time.

func (HelperMap) Helpers Uses

func (h HelperMap) Helpers() map[string]interface{}

Helpers returns the underlying list of helpers from the map

type Iterator Uses

type Iterator interface {
    Next() interface{}

Iterator type can be implemented and used by the `for` command to build loops in templates

type PartialFeeder Uses

type PartialFeeder func(string) (string, error)

PartialFeeder is callback function should implemented on application side.

type Template Uses

type Template struct {
    Input string
    // contains filtered or unexported fields

Template represents an input and helpers to be used to evaluate and render the input.

func NewTemplate Uses

func NewTemplate(input string) (*Template, error)

NewTemplate from the input string. Adds all of the global helper functions from "Helpers", this function does not cache the template.

func Parse Uses

func Parse(input string) (*Template, error)

Parse an input string and return a Template, and caches the parsed template.

func (*Template) Clone Uses

func (t *Template) Clone() *Template

Clone a template. This is useful for defining helpers on per "instance" of the template.

func (*Template) Exec Uses

func (t *Template) Exec(ctx hctx.Context) (string, error)

Exec the template using the content and return the results

func (*Template) Parse Uses

func (t *Template) Parse() error

Parse the template this can be called many times as a successful result is cached and is used on subsequent uses.



Package plush imports 19 packages (graph) and is imported by 164 packages. Updated 2020-01-16. Refresh now. Tools for package owners.