v5 – github.com/gobuffalo/plush/v5 Index | Examples | Files | Directories

package plush

import "github.com/gobuffalo/plush/v5"

Index

Examples

Variables 

var CacheEnabled bool
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 Helpers = helpers.NewMap(map[string]interface{}{})

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.

Functions

func BuffaloRenderer 

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 CacheSet 

func CacheSet(key string, t *Template)

func GroupByHelper 

func GroupByHelper(size int, underlying interface{}) (*groupBy, error)

func PartialHelper 

func PartialHelper(name string, data map[string]interface{}, help HelperContext) (template.HTML, error)

func Render 

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

Render a string using the given the context.

Example

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

Code: 

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

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

	s, err := plush.Render(html, ctx)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Print(s)
	// output: <html>
	//
	// <ul>
	//
	//	<li>John</li>
	//
	//	<li>Paul</li>
	//
	//	<li>George</li>
	//
	//	<li>Ringo</li>
	//
	// </ul>
	//
	// </html>
}

Output:

<html>

<ul>

	<li>John</li>

	<li>Paul</li>

	<li>George</li>

	<li>Ringo</li>

</ul>

</html>
Example (CustomHelperFunctions)

Code: 

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

	ctx := plush.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 plush.HelperContext) (template.HTML, error) {
		if s == "update" {
			h, err := help.Block()
			return template.HTML(h), err
		}
		return "", nil
	})

	s, err := plush.Render(html, ctx)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print(s)
	// output: <p>1</p>
	// <p>Hi mark</p>
	//
	// <p>i can update</p>
}

Output:

<p>1</p>
<p>Hi mark</p>

<p>i can update</p>
Example (ForIterator)

Code: 

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

	s, err := plush.Render(html, plush.NewContext())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print(s)
	// output: 45
}

Output:

45
Example (ScripletTags)

Code: 

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

	s, err := plush.Render(html, plush.NewContext())
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print(s)
	// output:<h1>hi mark</h1>
}

Output:

<h1>hi mark</h1>

func RenderR 

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

func RunScript 

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

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

Types

type Context 

type Context struct {
	context.Context
	// contains filtered or unexported fields
}

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

func NewContext 

func NewContext() *Context

NewContext returns a fully formed context ready to go

func NewContextWith 

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

NewContextWith returns a fully formed context using the data provided.

func NewContextWithContext 

func NewContextWithContext(ctx context.Context) *Context

NewContextWithContext returns a new plush.Context given another context

func NewContextWithOuter 

func NewContextWithOuter(data map[string]interface{}, out *Context) *Context

NewContextWith returns a fully formed context using the data provided and setting the outer context with the passed seccond argument.

func (*Context) Has 

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

Has checks the existence of the key in the context.

func (*Context) New 

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 

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

Set a value onto the context

func (*Context) Update 

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

func (*Context) Value 

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

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

type ErrUnknownIdentifier 

type ErrUnknownIdentifier struct {
	ID  string
	Err error
}

func (*ErrUnknownIdentifier) Error 

func (e *ErrUnknownIdentifier) Error() string

type HTMLer 

type HTMLer interface {
	HTML() template.HTML
}

HTMLer generates HTML source

type HelperContext 

type HelperContext struct {
	hctx.Context
	// 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 

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 

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 

func (h HelperContext) HasBlock() bool

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

func (HelperContext) Render 

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

Render a string with the current context

type InternTable 

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

func NewInternTable 

func NewInternTable() *InternTable

func (*InternTable) Intern 

func (it *InternTable) Intern(name string) int

func (*InternTable) Lookup 

func (it *InternTable) Lookup(name string) (int, bool)

func (*InternTable) SymbolName 

func (it *InternTable) SymbolName(id int) string

type Iterator 

type Iterator interface {
	Next() interface{}
}

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

type PartialFeeder 

type PartialFeeder func(string) (string, error)

PartialFeeder is callback function should implemented on application side.

type SymbolTable 

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

SymbolTable represents a scope

func NewScope 

func NewScope(parent *SymbolTable) *SymbolTable

NewScope creates a new scope with an optional parent

func (*SymbolTable) Assign 

func (s *SymbolTable) Assign(name string, value interface{}) bool

Assign searches outer scopes and updates an existing variable

func (*SymbolTable) Declare 

func (s *SymbolTable) Declare(name string, value interface{})

Declare adds or updates a variable in the current scope

func (*SymbolTable) Has 

func (s *SymbolTable) Has(name string) bool

Has finds the value of a variable

func (*SymbolTable) Resolve 

func (s *SymbolTable) Resolve(name string) (interface{}, bool)

Resolve finds the value of a variable

type Template 

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 

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 

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

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

func (*Template) Clone 

func (t *Template) Clone() *Template

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

func (*Template) Exec 

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

Exec the template using the content and return the results

func (*Template) Parse 

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.

Source Files

compiler.go context.go helper_context.go helpers.go intern.go iterators.go objects.go partial_helper.go plush.go symbol_table.go template.go user_function.go

Directories

PathSynopsis
ast
helpers
helpers/content
helpers/debug
helpers/encoders
helpers/env
helpers/escapes
helpers/hctx
helpers/helptest
helpers/inflections
helpers/iterators
helpers/meta
helpers/paths
helpers/text
lexer
parser
token
Version
v5.0.5 (latest)
Published
May 23, 2025
Platform
linux/amd64
Imports
18 packages
Last checked
2 weeks ago –

Tools for package owners.