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

package plush

import "github.com/gobuffalo/plush"

Index

Examples

Package Files

compiler.go content_helper.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

Constants

const Version = "v3.7.32"

Variables

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 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 BootstrapFormForHelper Uses

func BootstrapFormForHelper(model interface{}, opts tags.Options, help HelperContext) (template.HTML, error)

BootstrapFormForHelper implements a Plush helper around the bootstrap.NewFormFor function in the github.com/gobuffalo/tags/form/bootstrap package

func BootstrapFormHelper Uses

func BootstrapFormHelper(opts tags.Options, help HelperContext) (template.HTML, error)

BootstrapFormHelper implements a Plush helper around the bootstrap.New function in the github.com/gobuffalo/tags/form/bootstrap package

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 FormForHelper Uses

func FormForHelper(model interface{}, opts tags.Options, help HelperContext) (template.HTML, error)

FormForHelper implements a Plush helper around the form.NewFormFor function in the github.com/gobuffalo/tags/form package

func FormHelper Uses

func FormHelper(opts tags.Options, help HelperContext) (template.HTML, error)

FormHelper implements a Plush helper around the form.New function in the github.com/gobuffalo/tags/form package

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 *Context) (string, error)

Render a string using the given the context.

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>

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>

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

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>

func RenderR Uses

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

func RunScript Uses

func RunScript(input string, ctx *Context) error

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

type Context Uses

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 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() *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 HTMLer Uses

type HTMLer interface {
    HTML() template.HTML
}

HTMLer generates HTML source

type HelperContext Uses

type HelperContext struct {
    *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 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(ctx *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 *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.

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

Package plush imports 22 packages (graph) and is imported by 69 packages. Updated 2018-12-09. Refresh now. Tools for package owners.