amber: github.com/eknkc/amber Index | Files | Directories

package amber

import "github.com/eknkc/amber"

Package amber is an elegant templating engine for Go Programming Language. It is inspired from HAML and Jade.

Tags

A tag is simply a word:

html

is converted to

<html></html>

It is possible to add ID and CLASS attributes to tags:

div#main
span.time

are converted to

<div id="main"></div>
<span class="time"></span>

Any arbitrary attribute name / value pair can be added this way:

a[href="http://www.google.com"]

You can mix multiple attributes together

a#someid[href="/"][title="Main Page"].main.link Click Link

gets converted to

<a id="someid" class="main link" href="/" title="Main Page">Click Link</a>

It is also possible to define these attributes within the block of a tag

a
    #someid
    [href="/"]
    [title="Main Page"]
    .main
    .link
    | Click Link

Doctypes

To add a doctype, use `!!!` or `doctype` keywords:

!!! transitional
// <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

or use `doctype`

doctype 5
// <!DOCTYPE html>

Available options: `5`, `default`, `xml`, `transitional`, `strict`, `frameset`, `1.1`, `basic`, `mobile`

Tag Content

For single line tag text, you can just append the text after tag name:

p Testing!

would yield

<p>Testing!</p>

For multi line tag text, or nested tags, use indentation:

html
    head
        title Page Title
    body
        div#content
            p
                | This is a long page content
                | These lines are all part of the parent p

                a[href="/"] Go To Main Page

Data

Input template data can be reached by key names directly. For example, assuming the template has been executed with following JSON data:

{
    "Name": "Ekin",
    "LastName": "Koc",
    "Repositories": [
        "amber",
        "dateformat"
    ],
    "Avatar": "/images/ekin.jpg",
    "Friends": 17
}

It is possible to interpolate fields using `#{}`

p Welcome #{Name}!

would print

<p>Welcome Ekin!</p>

Attributes can have field names as well

a[title=Name][href="/ekin.koc"]

would print

<a title="Ekin" href="/ekin.koc"></a>

Expressions

Amber can expand basic expressions. For example, it is possible to concatenate strings with + operator:

p Welcome #{Name + " " + LastName}

Arithmetic expressions are also supported:

p You need #{50 - Friends} more friends to reach 50!

Expressions can be used within attributes

img[alt=Name + " " + LastName][src=Avatar]

Variables

It is possible to define dynamic variables within templates, all variables must start with a $ character and can be assigned as in the following example:

div
    $fullname = Name + " " + LastName
    p Welcome #{$fullname}

If you need to access the supplied data itself (i.e. the object containing Name, LastName etc fields.) you can use `$` variable

p $.Name

Conditions

For conditional blocks, it is possible to use `if <expression>`

div
    if Friends > 10
        p You have more than 10 friends
    else if Friends > 5
        p You have more than 5 friends
    else
        p You need more friends

Again, it is possible to use arithmetic and boolean operators

div
    if Name == "Ekin" && LastName == "Koc"
        p Hey! I know you..

There is a special syntax for conditional attributes. Only block attributes can have conditions;

div
    .hasfriends ? Friends > 0

This would yield a div with `hasfriends` class only if the `Friends > 0` condition holds. It is perfectly fine to use the same method for other types of attributes:

div
    #foo ? Name == "Ekin"
    [bar=baz] ? len(Repositories) > 0

Iterations

It is possible to iterate over arrays and maps using `each`:

each $repo in Repositories
    p #{$repo}

would print

p amber
p dateformat

It is also possible to iterate over values and indexes at the same time

each $i, $repo in Repositories
    p
        .even ? $i % 2 == 0
        .odd ? $i % 2 == 1

Includes

A template can include other templates using `include`:

a.amber
    p this is template a

b.amber
    p this is template b

c.amber
    div
        include a
        include b

gets compiled to

div
    p this is template a
    p this is template b

Inheritance

A template can inherit other templates. In order to inherit another template, an `extends` keyword should be used. Parent template can define several named blocks and child template can modify the blocks.

master.amber
    !!! 5
    html
        head
            block meta
                meta[name="description"][content="This is a great website"]

            title
                block title
                    | Default title
        body
            block content

subpage.amber
    extends master

    block title
        | Some sub page!

    block append meta
        // This will be added after the description meta tag. It is also possible
        // to prepend something to an existing block
        meta[name="keywords"][content="foo bar"]

    block content
        div#main
            p Some content here

License (The MIT License)

Copyright (c) 2012 Ekin Koc <ekin@eknkc.com>

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Index

Package Files

compiler.go doc.go runtime.go

Variables

var DefaultDirOptions = DirOptions{".amber", true}

DefaultDirOptions sets expected file extension to ".amber" and recursive search for templates within a directory to true.

var DefaultOptions = Options{true, false, nil}

DefaultOptions sets pretty-printing to true and line numbering to false.

var FuncMap = template.FuncMap{
    "__amber_add":   runtime_add,
    "__amber_sub":   runtime_sub,
    "__amber_mul":   runtime_mul,
    "__amber_quo":   runtime_quo,
    "__amber_rem":   runtime_rem,
    "__amber_minus": runtime_minus,
    "__amber_plus":  runtime_plus,
    "__amber_eql":   runtime_eql,
    "__amber_gtr":   runtime_gtr,
    "__amber_lss":   runtime_lss,

    "json":      runtime_json,
    "unescaped": runtime_unescaped,
}

func Compile Uses

func Compile(input string, options Options) (*template.Template, error)

Compile parses and compiles the supplied amber template string. Returns corresponding Go Template (html/templates) instance. Necessary runtime functions will be injected and the template will be ready to be executed.

func CompileData Uses

func CompileData(input []byte, filename string, options Options) (*template.Template, error)

Compile parses and compiles the supplied amber template []byte. Returns corresponding Go Template (html/templates) instance. Necessary runtime functions will be injected and the template will be ready to be executed.

func CompileDir Uses

func CompileDir(dirname string, dopt DirOptions, opt Options) (map[string]*template.Template, error)

CompileDir parses and compiles the contents of a supplied directory path, with options. Returns a map of a template identifier (key) to a Go Template instance. Ex: if the dirname="templates/" had a file "index.amber" the key would be "index" If option for recursive is True, this parses every file of relevant extension in all subdirectories. The key then is the path e.g: "layouts/layout"

func CompileFile Uses

func CompileFile(filename string, options Options) (*template.Template, error)

CompileFile parses and compiles the contents of supplied filename. Returns corresponding Go Template (html/templates) instance. Necessary runtime functions will be injected and the template will be ready to be executed.

func MustCompile Uses

func MustCompile(input string, options Options) *template.Template

MustCompile is the same as Compile, except the input is assumed error free. If else, panic.

func MustCompileDir Uses

func MustCompileDir(dirname string, dopt DirOptions, opt Options) map[string]*template.Template

MustCompileDir is the same as CompileDir, except input is assumed error free. If else, panic.

func MustCompileFile Uses

func MustCompileFile(filename string, options Options) *template.Template

MustCompileFile is the same as CompileFile, except the input is assumed error free. If else, panic.

type Compiler Uses

type Compiler struct {
    // Compiler options
    Options
    // contains filtered or unexported fields
}

Compiler is the main interface of Amber Template Engine. In order to use an Amber template, it is required to create a Compiler and compile an Amber source to native Go template.

compiler := amber.New()
// Parse the input file
err := compiler.ParseFile("./input.amber")
if err == nil {
	// Compile input file to Go template
	tpl, err := compiler.Compile()
	if err == nil {
		// Check built in html/template documentation for further details
		tpl.Execute(os.Stdout, somedata)
	}
}

func New Uses

func New() *Compiler

New creates and initialize a new Compiler.

func (*Compiler) Compile Uses

func (c *Compiler) Compile() (*template.Template, error)

Compile amber and create a Go Template (html/templates) instance. Necessary runtime functions will be injected and the template will be ready to be executed.

func (*Compiler) CompileString Uses

func (c *Compiler) CompileString() (string, error)

CompileString compiles the template and returns the Go Template source. You would not be using this unless debugging / checking the output. Please use Compile method to obtain a template instance directly.

func (*Compiler) CompileWithName Uses

func (c *Compiler) CompileWithName(name string) (*template.Template, error)

CompileWithName is the same as Compile, but allows to specify a name for the template.

func (*Compiler) CompileWithTemplate Uses

func (c *Compiler) CompileWithTemplate(t *template.Template) (*template.Template, error)

CompileWithTemplate is the same as Compile but allows to specify a template.

func (*Compiler) CompileWriter Uses

func (c *Compiler) CompileWriter(out io.Writer) (err error)

CompileWriter compiles amber and writes the Go Template source into given io.Writer instance. You would not be using this unless debugging / checking the output. Please use Compile method to obtain a template instance directly.

func (*Compiler) Parse Uses

func (c *Compiler) Parse(input string) (err error)

Parse given raw amber template string.

func (*Compiler) ParseData Uses

func (c *Compiler) ParseData(input []byte, filename string) (err error)

Parse given raw amber template bytes, and the filename that belongs with it

func (*Compiler) ParseFile Uses

func (c *Compiler) ParseFile(filename string) (err error)

ParseFile parses the amber template file in given path.

type DirOptions Uses

type DirOptions struct {
    // File extension to match for compilation
    Ext string
    // Whether or not to walk subdirectories
    Recursive bool
}

DirOptions is used to provide options to directory compilation.

type Options Uses

type Options struct {
    // Setting if pretty printing is enabled.
    // Pretty printing ensures that the output html is properly indented and in human readable form.
    // If disabled, produced HTML is compact. This might be more suitable in production environments.
    // Default: true
    PrettyPrint bool
    // Setting if line number emitting is enabled
    // In this form, Amber emits line number comments in the output template. It is usable in debugging environments.
    // Default: false
    LineNumbers bool
    // Setting the virtual filesystem to use
    // If set, will attempt to use a virtual filesystem provided instead of os.
    // Default: nil
    VirtualFilesystem http.FileSystem
}

Options defines template output behavior.

Directories

PathSynopsis
amberc
parser

Package amber imports 19 packages (graph) and is imported by 341 packages. Updated 2018-12-13. Refresh now. Tools for package owners.