A sweet velvety templating package

Overview

Velvet GoDoc Build Status Code Climate

Velvet is a templating package for Go. It bears a striking resemblance to "handlebars" based templates, there are a few small changes/tweaks, that make it slightly different.

General Usage

If you know handlebars, you basically know how to use Velvet.

Let's assume you have a template (a string of some kind):

<!-- some input -->
<h1>{{ name }}</h1>
<ul>
  {{#each names}}
    <li>{{ @value }}</li>
  {{/each}}
</ul>

Given that string, you can render the template like such:

ctx := velvet.NewContext()
ctx.Set("name", "Mark")
ctx.Set("names", []string{"John", "Paul", "George", "Ringo"})
s, err := velvet.Render(input, ctx)
if err != nil {
  // handle errors
}

Which would result in the following output:

<h1>Mark</h1>
<ul>
  <li>John</li>
  <li>Paul</li>
  <li>George</li>
  <li>Ringo</li>
</ul>

Helpers

If Statements

What to do? Should you render the content, or not? Using Velvet's built in if, else, and unless helpers, let you figure it out for yourself.

{{#if true }}
  render this
{{/if}}

Else Statements

{{#if false }}
  won't render this
{{ else }}
  render this
{{/if}}

Unless Statements

{{#unless true }}
  won't render this
{{/unless}}

Each Statements

Into everyone's life a little looping must happen. We can't avoid the need to write loops in applications, so Velvet helps you out by coming loaded with an each helper to iterate through arrays, slices, and maps.

Arrays

When looping through arrays or slices, the block being looped through will be access to the "global" context, as well as have four new variables available within that block:

  • @first [bool] - is this the first pass through the iteration?
  • @last [bool] - is this the last pass through the iteration?
  • @index [int] - the counter of where in the loop you are, starting with 0.
  • @value - the current element in the array or slice that is being iterated over.
<ul>
  {{#each names}}
    <li>{{ @index }} - {{ @value }}</li>
  {{/each}}
</ul>

By using "block parameters" you can change the "key" of the element being accessed from @value to a key of your choosing.

<ul>
  {{#each names as |name|}}
    <li>{{ name }}</li>
  {{/each}}
</ul>

To change both the key and the index name you can pass two "block parameters"; the first being the new name for the index and the second being the name for the element.

<ul>
  {{#each names as |index, name|}}
    <li>{{ index }} - {{ name }}</li>
  {{/each}}
</ul>

Maps

Looping through maps using the each helper is also supported, and follows very similar guidelines to looping through arrays.

  • @first [bool] - is this the first pass through the iteration?
  • @last [bool] - is this the last pass through the iteration?
  • @key - the key of the pair being accessed.
  • @value - the value of the pair being accessed.
<ul>
  {{#each users}}
    <li>{{ @key }} - {{ @value }}</li>
  {{/each}}
</ul>

By using "block parameters" you can change the "key" of the element being accessed from @value to a key of your choosing.

<ul>
  {{#each users as |user|}}
    <li>{{ @key }} - {{ user }}</li>
  {{/each}}
</ul>

To change both the key and the value name you can pass two "block parameters"; the first being the new name for the key and the second being the name for the value.

<ul>
  {{#each users as |key, user|}}
    <li>{{ key }} - {{ user }}</li>
  {{/each}}
</ul>

Other Builtin Helpers

  • json - returns a JSON marshaled string of the value passed to it.
  • js_escape - safely escapes a string to be used in a JavaScript bit of code.
  • html_escape - safely escapes a string to be used in an HTML bit of code.
  • upcase - upper cases the entire string passed to it.
  • downcase - lower cases the entire string passed to it.
  • markdown - converts markdown to HTML.
  • len - returns the length of an array or slice

Velvet also imports all of the helpers found https://github.com/markbates/inflect/blob/master/helpers.go

Custom Helpers

No templating package would be complete without allowing for you to build your own, custom, helper functions.

Return Values

The first thing to understand about building custom helper functions is their are a few "valid" return values:

string

Return just a string. The string will be HTML escaped, and deemed "not"-safe.

func() string {
  return ""
}

string, error

Return a string and an error. The string will be HTML escaped, and deemed "not"-safe.

func() (string, error) {
  return "", nil
}

template.HTML

https://golang.org/pkg/html/template/#HTML

Return a template.HTML string. The template.HTML will not be HTML escaped, and will be deemed safe.

func() template.HTML {
  return template.HTML("")
}

template.HTML, error

Return a template.HTML string and an error. The template.HTML will not be HTML escaped, and will be deemed safe.

func() ( template.HTML, error ) {
  return template.HTML(""), error
}

Input Values

Custom helper functions can take any type, and any number of arguments. There is an option last argument, velvet.HelperContext, that can be received. It's quite useful, and I would recommend taking it, as it provides you access to things like the context of the call, the block associated with the helper, etc...

Registering Helpers

Custom helpers can be registered in one of two different places; globally and per template.

Global Helpers

err := velvet.Helpers.Add("greet", func(name string) string {
  return fmt.Sprintf("Hi %s!", name)
})
if err != nil {
  // handle errors
}

The greet function is now available to all templates that use Velvet.

s, err := velvet.Render(`<h1>{{greet "mark"}}</h1>`, velvet.NewContext())
if err != nil {
  // handle errors
}
fmt.Print(s) // <h1>Hi mark!</h1>

Per Template Helpers

t, err := velvet.Parse(`<h1>{{greet "mark"}}</h1>`)
if err != nil {
  // handle errors
}
t.Helpers.Add("greet", func(name string) string {
  return fmt.Sprintf("Hi %s!", name)
})
if err != nil {
  // handle errors
}

The greet function is now only available to the template it was added to.

s, err := t.Exec(velvet.NewContext())
if err != nil {
  // handle errors
}
fmt.Print(s) // <h1>Hi mark!</h1>

Block Helpers

Like the if and each helpers, block helpers take a "block" of text that can be evaluated and potentially rendered, manipulated, or whatever you would like. To write a block helper, you have to take the velvet.HelperContext as the last argument to your helper function. This will give you access to the block associated with that call.

Example

velvet.Helpers.Add("upblock", func(help velvet.HelperContext) (template.HTML, error) {
  s, err := help.Block()
  if err != nil {
    return "", err
  }
  return strings.ToUpper(s), nil
})

s, err := velvet.Render(`{{#upblock}}hi{{/upblock}}`, velvet.NewContext())
if err != nil {
  // handle errors
}
fmt.Print(s) // HI
Issues
  • Comment

    Comment

    I don't see it documented anyplace, but is it possible add comments to the template? For example: {{#comment This text will not be rendered, or shown in the html }}

    opened by goldbattle 3
  • Edit some typo

    Edit some typo

    I find some typo, not sure if correct.

    opened by janczer 1
  • [cleaning] fixing an issue with empty values for maps/slices inside maps

    [cleaning] fixing an issue with empty values for maps/slices inside maps

    @markbates this solves what i commented on https://github.com/gobuffalo/buffalo/pull/143, regards!

    opened by paganotoni 0
  • 0.8.0

    0.8.0

    opened by markbates 0
  • 0.8.0

    0.8.0

    opened by markbates 0
  • Any thought to support dot accessors for fields?

    Any thought to support dot accessors for fields?

    It's be nice to iterate over a list of maps or something and access values like {{ @value.display_name }}, especially if there is potentially several bits of data I want to attach to the values and use elsewhere in the template.

    I tried this:

    Players in room:
    {{#each players}}{{ @value.display_name }}
    {{/each}}
    

    (I'm using this for text, not HTML so it gets weird).

    The data passed to the template was:

    var data = map[string]interface{}{
            "players": []map[string]interface{}{
                    {"display_name": "PlayerOne"},
                    {"display_name": "PlayerTwo"},
            },
    }
    opened by bbuck 0
  • Be able to change the interpolation delimiters

    Be able to change the interpolation delimiters

    This is so that Velvet can play nice with Handlebars in the case of a SPA frontend being used with Buffalo.

    Original issue here: https://github.com/gobuffalo/buffalo/issues/127

    opened by howdoicomputer 0
Owner
Buffalo - The Go Web Eco-System
Buffalo - The Go Web Eco-System
An ERB-style templating language for Go.

Ego Ego is an ERb style templating language for Go. It works by transpiling templates into pure Go and including them at compile time. These templates

Ben Johnson 504 Sep 13, 2021
Templating system for HTML and other text documents - go implementation

FAQ What is Kasia.go? Kasia.go is a Go implementation of the Kasia templating system. Kasia is primarily designed for HTML, but you can use it for any

Michał Derkacz 72 May 4, 2021
Programatic document generation as a HTTP service. Render PDFs using LaTeX templates and JSON.

LaTTe Generate PDFs using LaTeX templates and JSON. Try out the demo! Find LaTTe on Docker Hub Table of Contents About Obtaining LaTTe Running & Using

Raphael Reyna 164 Aug 25, 2021
pongo2 is a Django-syntax like templating-language

Django-syntax like template-engine for Go

Florian Schlachter 2k Sep 14, 2021
The powerful template system that Go needs

Plush Plush is the templating system that Go both needs and deserves. Powerful, flexible, and extendable, Plush is there to make writing your template

Buffalo - The Go Web Eco-System 655 Sep 7, 2021
Amber is an elegant templating engine for Go Programming Language, inspired from HAML and Jade

amber Notice While Amber is perfectly fine and stable to use, I've been working on a direct Pug.js port for Go. It is somewhat hacky at the moment but

Ekin Koc 879 Aug 23, 2021
Fast, powerful, yet easy to use template engine for Go. Optimized for speed, zero memory allocations in hot paths. Up to 20x faster than html/template

quicktemplate A fast, powerful, yet easy to use template engine for Go. Inspired by the Mako templates philosophy. Features Extremely fast. Templates

Aliaksandr Valialkin 2.2k Sep 12, 2021
A PDF document generator with high level support for text, drawing and images

GoFPDF document generator Package gofpdf implements a PDF document generator with high level support for text, drawing and images. Features UTF-8 supp

Kurt Jung 3.9k Sep 12, 2021
Package damsel provides html outlining via css-selectors and common template functionality.

Damsel Markup language featuring html outlining via css-selectors, extensible via pkg html/template and others. Library This package expects to exist

Daniel Skinner 24 Sep 12, 2020
A complete Liquid template engine in Go

Liquid Template Parser liquid is a pure Go implementation of Shopify Liquid templates. It was developed for use in the Gojekyll port of the Jekyll sta

Oliver Steele 134 Sep 3, 2021
Simple system for writing HTML/XML as Go code. Better-performing replacement for html/template and text/template

Simple system for writing HTML as Go code. Use normal Go conditionals, loops and functions. Benefit from typing and code analysis. Better performance than templating. Tiny and dependency-free.

Nelo Mitranim 3 Sep 8, 2021
A template to build dynamic web apps quickly using Go, html/template and javascript

gomodest-template A modest template to build dynamic web apps in Go, HTML and sprinkles and spots of javascript. Why ? Build dynamic websites using th

Adnaan Badr 54 Aug 28, 2021
Razor view engine for go

gorazor gorazor is the Go port of the razor view engine originated from asp.net in 2011. In summary, gorazor is: Extremely Fast. Templates are convert

null 787 Sep 13, 2021
Goview is a lightweight, minimalist and idiomatic template library based on golang html/template for building Go web application.

goview Goview is a lightweight, minimalist and idiomatic template library based on golang html/template for building Go web application. Contents Inst

foolin 244 Aug 31, 2021
HTML template engine for Go

Ace - HTML template engine for Go Overview Ace is an HTML template engine for Go. This is inspired by Slim and Jade. This is a refinement of Gold. Exa

Keiji Yoshida 803 Sep 10, 2021
The world’s most powerful template engine and Go embeddable interpreter.

The world’s most powerful template engine and Go embeddable interpreter

Open2b 17 Sep 15, 2021
Handlebars for golang

raymond Handlebars for golang with the same features as handlebars.js 3.0. The full API documentation is available here: http://godoc.org/github.com/a

Aymerick 440 Aug 27, 2021
Useful template functions for Go templates.

Sprig: Template functions for Go templates The Go language comes with a built-in template language, but not very many template functions. Sprig is a l

null 2.5k Sep 14, 2021
Template for advanced Telegram bots using telebot.v3

Telebot Template $ git clone https://github.com/massbots/template . $ chmod +x init.sh; ./init.sh NOTE The script will delete itself after the configu

MassBots 6 Sep 9, 2021