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

package plush

import "github.com/gobuffalo/plush"

Index

Examples

Constants 

const Version = "v3.8.3"

Variables 

var BootstrapFormForHelper = bootstrap.FormFor

BootstrapFormForHelper is deprecated use github.com/gobuffalo/helpers/forms/bootstrap#FormFor instead. 

var BootstrapFormHelper = bootstrap.Form

BootstrapFormHelper is deprecated use github.com/gobuffalo/helpers/forms/bootstrap#Form 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 ErrUnknownIdentifier = errors.New("unknown identifier")
var FormForHelper = forms.FormFor

FormForHelper is deprecated use github.com/gobuffalo/helpers/forms#FormFor instead. 

var FormHelper = forms.Form

FormHelper is deprecated use github.com/gobuffalo/helpers/forms#Form 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.

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 MarkdownHelper 

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

Markdown converts the string into HTML using GitHub flavored markdown.

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 := NewContext()
	ctx.Set("names", []string{"john", "paul", "george", "ringo"})

	s, err := 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 := 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 {
		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 := Render(html, 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 := Render(html, 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 (*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) Value 

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

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

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 HelperMap 

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

HelperMap holds onto helpers and validates they are properly formed.

func NewHelperMap 

func NewHelperMap() (HelperMap, error)

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

func (*HelperMap) Add 

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 

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

AddMany helpers at the same time.

func (HelperMap) Helpers 

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

Helpers returns the underlying list of helpers from the map

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 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 forms.go helper_map.go helpers.go iterators.go markdown_helper.go partial_helper.go plush.go template.go user_function.go version.go

Directories

PathSynopsis
ast
lexer
packrdYou can use the "packr2 clean" command to clean up this, and any other packr generated files.
parser
plush
plush/cmd
token
Version
v3.8.3+incompatible (latest)
Published
Jul 15, 2019
Platform
linux/amd64
Imports
20 packages
Last checked
4 days ago –

Tools for package owners.